The AI Context Platform for Engineering Teams
Give your AI agents the context they need
SystemDox is the structured, machine-readable source of truth that AI coding agents consume. Your architecture decisions, checks, and domain knowledge — delivered to every AI session automatically.
Free for your first repo — book a demo to roll out org-wide.
One platform, three surfaces
Capture → Build → Document
Requirements arrive as messily as they occur to you. SystemDox turns them into specs your team refines, and documentation your AI agents can actually read.
Capture
1Add, browse and publish your documentation
A voice note after a client call, a photo of a whiteboard, a dropped-in PDF, plain text. AI refines each one into a structured requirement or design. The same surface holds the whole doc library — requirements, designs and everything else — with gap analysis for what nobody has thought of yet, and the button that publishes it.
opens straight in the editor → Build
Build
2What your AI reads
The standards, specs and plans your agents build on: ADRs, checks, epics, stories and GitHub issues. Agents pull them through the MCP server before they generate code, and fitness tests check what comes back. The code itself is written in your own AI tool, not here.
only on an explicit publish → Document
Document
3A portal humans and agents both read
Any markdown tree in a repository you connect becomes a searchable read-only portal on your own subdomain, with staleness detection flagging whatever has drifted out of date. It is served to the whole internet until you lock it to your tenant.
Capture what you learn, Build what you decided, and Document what you shipped — for the people on your team and the agents working alongside them.
AI coding agents are powerful but context-starved
Claude Code, Copilot, Cursor and other AI agents generate code fast — but they guess at the things that matter most.
Architecture decisions & constraints
Which patterns are approved, which are banned, and why those choices were made.
Business rules & domain logic
The domain-specific rules that code must respect — not inferable from syntax alone.
Compliance & regulatory checks
Security, privacy, and regulatory requirements that every change must satisfy.
Naming conventions & banned approaches
Your team's conventions, preferred patterns, and explicitly prohibited anti-patterns.
Dependencies & integration contracts
How services talk to each other, shared schemas, and cross-repo boundaries.
SystemDox solves this
The structured, machine-readable source of truth that AI agents consume — so they stop guessing and start following your standards.
How it works
A context engine for AI agents
SystemDox indexes your architecture knowledge — requirements, ADRs, checks, domain terms, integration contracts — and delivers the right context to the right agent at the right time.
Requirements
Specs & Given/When/Then
ADRs & Checks
Decisions & banned patterns
Knowledge Base
Patterns, APIs, domain terms
Context Engine
Index, rank, and retrieve relevant context per task
MCP Server
Real-time, interactive
Static Export
CLAUDE.md, .cursorrules
Claude Code / Cursor / VS Code
Static files in repos
Two ways to deliver context
Meet AI agents where they are
Real-time context for every AI session
SystemDox exposes an MCP server that AI coding tools connect to directly. When an agent is working on code, it queries SystemDox for the context it needs — in real time.
This is the highest-value integration. It makes AI context-aware while it writes code, not after.
Works with Claude Code, Cursor, VS CodeMCP Queries
get_architecture_decisions
(domain: "auth") → relevant ADRs
get_checks
(language: "python", area: "api") → banned + required patterns
get_specs
(feature: "user-signup") → Given/When/Then specs
search_knowledge
(query: "how does billing work") → relevant docs
Auto-generated context files in every repo
Generate repo-specific CLAUDE.md, .cursorrules, and other context files directly from SystemDox content. No more manually maintaining context files across dozens of repositories.
When your architecture changes, SystemDox updates every repo automatically. Context files stay current because the platform maintains them.
Human reviews generated filesGenerated per repo
The knowledge AI agents actually need
Not just any documentation — the specific document types that make AI code generation accurate and safe.
ADRs
Architecture constraints
Decisions that constrain implementation choices across the codebase.
"Use PwebAuthoriser, never CognitoAuthorizer"
Checks
Banned & required patterns
Explicit rules about what code must and must not do.
"Never use Sentry.captureException directly"
Specs
Feature behaviour
Given/When/Then specifications that define expected behaviour.
"Given a user with free plan, When..."
Domain Glossary
Term definitions
Precise meaning of domain terms so AI uses the right concepts.
"Principal = user_id + tenant_id + role + scopes"
Integration Contracts
API shapes & events
Cross-repo dependency maps, event schemas, and shared interfaces.
"EventBridge: feedback.submitted → shared-support"
Runbooks
How to deploy & debug
Operational knowledge that AI needs when making infrastructure changes.
"CI_ENABLED variable controls the pipeline"
Not just another docs tool
SystemDox is purpose-built for AI consumption, not human browsing.
Bidirectional sync
AI agents don't just read from SystemDox — they write back. When Claude Code creates an ADR or discovers a pattern, it pushes it to SystemDox.
Your documentation stays current because the AI maintains it.
Context ranking
Not all docs are relevant to every task. SystemDox scores and filters context based on what files the agent is touching, what domain it's working in, and token budget constraints.
Right context, right time, right size.
Check enforcement
Instead of hoping developers read the docs, SystemDox feeds checks directly to the AI. The agent literally cannot ignore "don't use CognitoAuthorizer" because it's in its active context.
Standards enforced, not just documented.
Living specs
Specs written in SystemDox become test generation inputs. Given/When/Then specs aren't just documentation — they're executable context that generates tests automatically.
Documentation that does work, not just sits there.
The closed loop
Gets smarter with every sprint
Each failure becomes a check. Each check prevents recurrence. Architecture quality ratchets up automatically.
Capture
Record the standard
Decisions arrive by voice, photo, file or text. SystemDox indexes them as structured knowledge.
Execute
AI implements
AI agents read your ADRs, follow your checks, and open PRs. You review every one.
Validate
Fitness tests
Automated checks run on every PR. Violations caught before merge. Humans judge edge cases.
Learn
Failures → checks
Report an AI mistake. SystemDox generates a check + fitness test. The mistake never recurs.
AI proposes. Humans dispose.
AI accelerates
- • Drafts documents from recordings
- • Generates code from specs
- • Suggests checks from failures
- • Detects violations automatically
- • Delivers context via MCP in real time
Humans decide
- • Review and approve every document
- • Merge or reject every PR
- • Choose which rules to enforce
- • Judge what's worth improving
- • Own the architecture standards
AI does the 80% grunt work. Humans own the 20% that requires judgement.
Stop feeding AI agents blind
Give your AI coding agents the architecture context they need. Define your standards once. Deliver them everywhere. Verify automatically.
Free for your first repo — book a demo to roll out org-wide. See a live docs portal →