The Semantic Product Runtime
Your product has
a memory now.
Specor turns every feature, rule, flow, and decision into one living, versioned graph — checked continuously by AI and read live by your engineers' AI tools. Context never walks out the door.
No credit card · Viewers always free · Set up in minutes
Live demo — pick a feature, switch tabs, tap a rule. No signup.
Guest Checkout
FeatureLets shoppers complete a purchase without creating an account.
Needs (2)
Link NeedDecisions (1)
Record DecisionPlugs into the AI tools your engineers already use
What makes Specor different
A graph, not documents
Features, rules, flows, and decisions are connected and queryable — not prose that drifts out of date.
Versioned like Git
Branch, save, review, and revert your product definition — in plain English, no command line.
AI checks every commit
Coverage, conflict, compliance, security, and UX gaps caught automatically — for free.
Read live by your AI tools
Cursor, Claude, and Copilot pull the real spec over the open MCP standard before writing code.
Sound familiar?
Context walks out the door
When a PM leaves, the decisions, rationale, and history go with them. Nobody knows why it was built that way.
Six tools, zero sync
Product lives across Notion, Jira, Confluence, Miro, and Slack. Change one — the other five go stale immediately.
Developers still have to guess
Engineers read a two-sentence Jira ticket, ask a PM in Slack, and ship code that doesn't match what product intended.
In Specor these aren't scattered notes — they're connected. Change one thing, and Specor knows what else is affected.
How it works
From scattered context to a single source of truth
You don't start from a blank page, and you don't need to learn version control. Three steps — the same three you'll watch unfold down this page.
It remembers
Bring what you have — a meeting transcript, a PRD, your codebase, or plain English. Specor turns it into a structured spec: features, rules, flows, and decisions, all connected and versioned.
It reviews itself
Background agents review every change, flag gaps and conflicts, and propose fixes — instantly for per-node quality issues, and after each commit for compliance, UX, and security gaps.
It ships in sync
Everyone works from one source of truth. Developers connect their AI coding tools via MCP, so the code that gets written matches what product actually intended.
Who it's for
One product. Read differently by every team.
Everyone works from the same versioned source of truth — but each role gets the slice they care about.
Plus Living Documents — PRDs, briefs, and release notes generated straight from your graph, and flagged the moment they go stale.
Act 1 · It remembers
Watch one feature — Guest Checkout — enter Specor. You'll follow it down this whole page.
Multiple ways in
Bring what you have — watch your spec build itself
You don't need to start from a blank spec. Paste a meeting transcript, think out loud in chat, drop in a brief, or connect a GitHub repo — Specor turns any of them into a connected, versioned product graph.
Paste any meeting recording transcript or notes. Specor reads the discussion, proposes what should change in the spec, and stages it for your review and one-click commit.
You paste
"We agreed to drop mandatory signup from checkout. Pix payment should expire after 15 minutes — legal requirement. Guest users should be able to buy without creating an account."
Specor proposes
→ review on a draft branch, then commit
Full Version Control
Git for product — without the engineering degree
Branch off to explore a new direction. Merge when you're ready. Roll back anything if you change your mind. See exactly what changed between any two versions — in plain English, not code.
- ✓ Product Branches — Explore a pivot without touching main. Multiple squads work independently, then merge.
- ✓ Sealed Milestones — End-of-sprint snapshots with author stamps. Your product changelog writes itself.
- ✓ Non-destructive Rollback — Reverse any milestone safely. History is never deleted — rollback creates a new record.
- ✓ Full Immutable History — Every field, relationship, and decision — permanently recorded. Time-travel to any past state.
Semantic diff — plain English
+ Feature "Guest Checkout" introduced
+ Rule "Pix expires after 15 minutes" added
~ Feature "Standard Checkout" — status: active → deprecated
- Flow "Legacy Checkout Flow" removed
AI-written impact summary
Affected capabilities: Commerce › Checkout
Affected metrics: Checkout Conversion Rate (likely impacted)
Affected personas: Guest User (new), Returning Customer (unchanged)
Affected flows: 2 modified, 1 added, 1 removed
Every diff is a shareable link you can paste into Slack or a PR.
Act 2 · It reviews itself
Now Specor reads what you wrote. The Guest Checkout spec you just committed gets reviewed on every change.
Product Intelligence
Compliance, security & UX gaps — caught before your auditor does
Every time you seal a commit, Product Intelligence runs a deep, branch-level sweep. It checks your entire product spec against compliance frameworks and UX best practices — without consuming AI Token credits.
- ✓ Compliance & Security — Gaps mapped to SOC2, OWASP, and GDPR — auth rules, audit trails, rate limits, privilege escalation.
- ✓ UX & Flows — Missing login, signup, or password-reset paths. Destructive actions without a confirmation step.
- ✓ Product Completeness — Features without onboarding flows. Personas with no way to reach the product.
Findings live in a dedicated inbox — separate from Spec Quality — with framework badges, article references, and one-click resolution.
Product Intelligence
Findings from the last commit sweep
Features involving users must be governed by an auth rule. Missing auth coverage is flagged as SOC2 CC6.1.
Personas exist but there is no feature describing how they gain access to the product.
Public-facing features should be governed by an explicit rate-limit rule — OWASP A01 / SOC2 CC6.6.
Runs automatically on every commit seal. Zero AI credits consumed.
Plus six Spec Quality agents reviewing every node as you type
Instant per-node checks — "Guest Checkout has no Metric", "these two rules conflict" — surfaced for your approval, never auto-applied. Everything rolls up into a live 0–100 Product Health Score.
Product Health
Available agents vary by plan. Custom agents built to your vocabulary on Enterprise.
Act 3 · It ships in sync
The spec doesn't stop at the spec. The same Guest Checkout definition is what your engineers' AI tools read, what every merge is tested against, and where real metrics flow back in.
MCP Integration
Your engineers' AI tools read your product definition live
Specor ships an MCP server (Model Context Protocol) that connects to Cursor, Claude, VS Code Copilot, and any compatible AI coding tool. Once connected, the developer's AI reads your feature definitions, business rules, acceptance criteria, and user flows — automatically, in the background.
-
Implement a feature
AI reads your rules, ACs, and flows — writes code that matches what product intended.
-
Write tests
AI reads your acceptance criteria — generates one test per AC, grounded in your definition of done.
-
Debug a regression
AI reads recent milestones — surfaces the rule or decision that changed and caused the break.
-
Onboard to a new area
AI reads the domain overview — full product architecture before writing a single line.
Configure once in your editor
// ~/.cursor/mcp.json
{
"mcpServers": {
"specor": {
"url": "https://mcp.specor.ai/",
"headers": {
"Authorization": "Bearer spk_live_...",
"X-Workspace-ID": "your-workspace-uuid"
}
}
}
} After that — nothing. The AI assistant calls Specor automatically every time a developer starts implementing a feature. No copy-pasting docs, no interrupting PMs, no guessing.
Read the MCP docs →Merge Confidence
AI writes the test cases for every merge — before you confirm it
When a merge request is open, Specor reads its real semantic diff and generates Gherkin-style (Given/When/Then) test cases — one set for what actually changed, plus coverage for the "blast radius": nearby graph nodes that often regress without anyone touching them directly. A developer or QA manually verifies the real implementation against each case and marks it pass or fail.
- ✓ Grounded in the real diff — Test cases are generated from the merge's actual structural diff, not a generic checklist — they name the rule, feature, or flow that changed.
- ✓ Blast-radius coverage — Graph neighbors up to two hops from the change get a lighter-weight regression check, with a "why" explaining the dependency.
- ✓ Pass/fail merge gate — Branch protection can require every test case to pass before a merge confirms — no silent merges past unverified changes.
- ✓ Markable from your AI tool — List, review, and mark test cases pass/fail straight from Cursor or Claude via MCP — editors and admins only; viewers stay read-only.
1/2 test cases passed
Required to mergeGuest can complete checkout without an account
Direct changeCovers the new "no mandatory signup" rule on this feature.
Given a guest user with items in their cart
When they reach checkout without signing in
Then they can pay and receive an order confirmation
Pix payment link still expires after 15 minutes
Regression · 2 hopsRegression check: this Rule depends on the changed Checkout flow.
Given a guest checkout generates a Pix payment link
When 15 minutes pass without payment
Then the link is rejected as expired
GitHub Integration
Link a GitHub PR to a Specor MR — see where code and spec diverge
When you open a Specor merge request, attach the GitHub PR that implements it. Run a drift analysis and get two answers in one place: code that was written but has no spec node, and spec nodes that should be covered by the PR but aren't.
Code → Spec
Specor reads the diff, identifies logic that has no matching feature, rule, or flow — and proposes the missing spec nodes directly on the branch.
Spec → Code
Specor checks every spec node in scope for this PR. Nodes with no matching code surface as test cases on the MR: "Is this feature actually in the diff?"
Auto re-analysis on new commits
When the PR gets new commits, the drift analysis re-runs automatically. The Specor MR stays current without any manual action.
Inside the Specor MR
Code → Spec gaps (2)
⚠ No spec node for POST /api/refunds
⚠ No spec node for rate-limit logic in checkout.ts:84
Spec → Code gaps (1 test case)
? Is "Guest Checkout Flow" implemented in this PR?
PMs review the Specor MR. Devs review the GitHub PR. Both link to each other. When both are merged, code and spec are in sync.
Figma Integration
Link the design to the spec — and catch it when they drift
Attach a Figma frame to any node from the Specor plugin, right inside Figma. The link lives in the spec's history — it shows up in diffs, survives rollbacks, and travels across branches on merge. No OAuth to set up: the plugin reads the open file and pushes what Specor needs, so Specor never calls Figma's API on your behalf.
Design on the node
A live thumbnail sits on the node itself — no Figma login needed to look. Open the exact frame in Figma, or flip on an interactive live preview.
Spec ↔ design drift
Specor compares the pushed design against the spec and flags where they disagree — a rule the screen doesn't honor, a state the spec never mentions.
Design coverage
Features with no linked frame are surfaced by the Coverage agent — so a feature that shipped to spec but never got a design doesn't slip through.
On the node's Design panel
Product owns the spec. Design owns the file. The link between them is versioned, so spec and design never quietly drift apart.
Live Metrics
Your success metrics, live — not a number someone typed last quarter
Connect your analytics provider and bind a Metric to a real query. Specor pulls the current value and shows it against your target — right on the node and in a dashboard. It's the first time real-world data flows into your spec: a Feature's success metric reading 4.2% vs a 6% target — off track, not a stale guess.
- ✓ Connect your provider — PostHog and Google Analytics 4 today — Amplitude & Mixpanel next, behind one adapter. Keys are encrypted per workspace and set by an admin.
- ✓ Bind any Metric — Point a Metric node at a real insight. The binding is versioned like every other change — diffable and rollback-safe.
- ✓ On / off-track at a glance — Current value vs. target computed live, on the node and in a metrics dashboard, with staleness flagged if a provider hiccups.
- ✓ Mix providers freely — Different metrics can read from different tools. One dashboard, every source — no lock-in.
Metric · Live
Checkout Conversion Rate
Target 6.0% · higher is better
Live Examples
See what a real product structure looks like
We've modelled six real-world products in Specor — features, rules, flows, metrics, and decisions, all connected. View any of them live in the app — no signup required.
Uber
Ride-hailing platform — trip lifecycle, driver matching, surge pricing rules, and safety flows.
View live example →
Social media product — feed ranking, stories, creator monetisation, and content moderation rules.
View live example →
Nubank
Digital bank — credit card lifecycle, payment flows, fraud detection rules, and limit management.
View live example →
iFood
Food delivery marketplace — order lifecycle, restaurant onboarding, delivery SLA rules, and promotions.
View live example →
PayPal
Payments platform — send/receive money flows, buyer protection rules, dispute resolution, and KYC.
View live example →
Mercado Livre
E-commerce marketplace — listing lifecycle, bidding rules, seller reputation, and shipping flows.
View live example →
No account required — view any example instantly, right in the app.
These examples are illustrative product structures created by the Specor team for demonstration purposes only. They are not affiliated with, endorsed by, or representative of the actual products or companies depicted. All trademarks belong to their respective owners.
Not another doc tool
Every tool below tracks things. None of them know how those things relate.
| Specor | Notion / Confluence | Jira / Linear | ProductBoard / Aha! | |
|---|---|---|---|---|
| Structured semantic graph | ✓ Connected & versioned | ✗ Unstructured docs | ✗ Tickets and tasks | ~ Some relationships |
| Immutable history, time-travel & safe rollback | ✓ Every field, forever | ~ Last edited by | ~ Ticket log | ✗ Limited |
| AI detects spec gaps & conflicts | ✓ 6 Spec Quality agents | ✗ | ✗ | ~ Basic copilot |
| Compliance & security analysis (SOC2, OWASP, GDPR) | ✓ Product Intelligence | ✗ | ✗ | ✗ |
| Semantic branching & business-readable diffs | ✓ | ✗ | ✗ | ✗ |
| AI coding tools read it live (MCP) | ✓ | ✗ | ✗ | ✗ |
| Bootstrap spec from codebase + PR drift detection | ✓ GitHub integration | ✗ | ✗ | ✗ |
| Live metric values from analytics | ✓ PostHog, GA4 & more | ✗ | ✗ | ~ Manual KPIs |
| Sprint & ticket execution tracking | → Jira / Linear | ~ Basic boards | ✓ Core strength | ~ Roadmap-level |
Simple, transparent pricing
Free for your first editor. $99/month for teams. AI credits are included per plan, and viewer seats are always free.
Starter
Small teams — get started
$0 / 1st editor
+$25/additional editor · up to 5 editors total
- ✓1 workspace, up to 5 editor seats
- ✓100 AI credits/month
- ✓Coverage agent
- ✓Product Intelligence (compliance & UX checks)
- ✓Full history, no limits
- ✓MCP server access
- ✓All core features
Team
Product teams shipping together
$99/org/mo
First editor free · +$25/additional editor · unlimited editors
- ✓Up to 10 workspaces
- ✓Unlimited editor seats
- ✓1,000 AI credits/month
- ✓All 6 Spec Quality agents
- ✓Product Intelligence (compliance, security & UX analysis)
- ✓Semantic search across your product graph
- ✓Live metrics integration (PostHog, GA4 & more)
- ✓Priority support
- ✓Slack integration
- ✓GitHub integration
Enterprise
Multi-product organizations
Custom
Custom contract · volume AI credits or BYOA
- ✓Unlimited workspaces & seats
- ✓SSO / SAML (Okta, Azure AD)
- ✓Audit log & compliance exports
- ✓Self-hosted option
- ✓Bring your own AI (BYOA)
- ✓Custom AI agents for your ontology
- ✓Data residency (EU available)
- ✓99.95% SLA + status page
- ✓Dedicated Customer Success Manager
Example: a 5-person product team on Team pays $99 + 4 × $25 = $199/month (the first editor seat is free), with 1,000 AI credits and all 6 agents included.
Monthly total = org plan fee + (active editor seats × seat rate). Additional AI credits available at $0.05 / credit (minimum 100 credits per purchase), no expiry. Proactive agents are event-driven and never consume credits.
Why we built Specor
“Every product team I've worked on lost the same thing: the why. The decisions, the rules, the trade-offs — scattered across six tools and the heads of people who eventually leave. We built Specor so a product can finally remember itself.”
Daniel Ciolfi
Founder, Specor
Questions, answered
The things teams ask before they start.
Does Specor replace Jira, Notion, or Linear?
No — it sits alongside them. Jira and Linear track the work; Specor holds the definition of what the product is and why. Notion and Confluence hold prose that goes stale; Specor holds a structured, connected, versioned graph that stays consistent. Most teams keep their ticket tracker and use Specor as the single source of truth it points back to.
How long does it take to get started?
Minutes. You don't start from a blank graph — paste a meeting transcript, a PRD, or a plain-English description and Specor generates a structured spec you can review and commit. You can model your first feature in a single sitting.
Do I need to understand Git or version control?
No. Branches, commits, diffs, and rollback are presented in plain English — no command line, no merge syntax. If you can use a doc tool, you can use Specor.
Is my product data secure?
Every workspace is isolated with row-level security, and the full event history is immutable and auditable. Enterprise plans add SSO/SAML, MFA, audit-log exports, EU data residency, and a self-hosted option where your data never leaves your infrastructure.
What happens to my data if I stop paying?
Nothing is deleted. Your history is preserved and read access stays free — viewers never need a paid seat. You can export your full product state at any time. Downgrading simply limits new edits and seats, not access to what you've built.
How do the AI agents use credits?
The six Spec Quality agents and Product Intelligence checks are event-driven and never consume credits — they run in the background for free. Credits are only used for generative actions you trigger, like generating a spec from a description or an AI chat. Each plan includes a monthly credit allowance.
Give your product a permanent memory
Bring a transcript, a PRD, or your repo — you'll have a living, versioned spec in one sitting.
Enterprise
Book a team walkthrough
We'll walk through Specor with your team, answer your questions, and scope the right plan for your organization. Usually 30 minutes.
✓
Request received!
We'll reach out within one business day to schedule your walkthrough.