Archon isn't a linter — it's a governance engine. Nine review lenses, an adversarial challenger, and stage gates that catch design flaws before they become production incidents.
Architecture, API design, database schema, scalability, security, tradeoffs, features, implementation plans, and design documents — each reviewed by a dedicated lens with enterprise-grade checklists.
Actively tries to break your proposal. Adversarial scenarios — scale shocks, data corruption, auth compromise, contract changes, multi-tenancy leaks, size ceilings — each with severity and pre-build verification steps.
Five governance stages — intent, architecture, plan, risk, completion. Every submission gets a structured verdict with a pass/fail gate, so agents know exactly what must change before proceeding.
Every decision is recorded with its alternatives and reasoning. Outcomes close the loop — future reviews reference past decisions automatically, so your architecture knowledge compounds.
// Submit a design decision review_database("I chose SQLite instead of Postgres") // Archon returns: Review { pros: 4 // zero-ops, local-first... cons: 3 // write concurrency ceiling... verdict: "fit-for-purpose" long_term: "revisit at 10k users" } // Challenge it: challenge_proposal("single-node SQLite store") → 3 adversarial scenarios 1 high-severity: multi-tenancy
Nine lenses, one adversarial challenger, five governance gates, and a memory that never forgets why.
Architecture, API, database, scalability, security, design, feature, plan, and tradeoffs. Every lens ships with enterprise profiles, custom standards, and persona-aware feedback.
Adversarial review with 6 attack categories: scale shock, corruption, auth compromise, contract change, multi-tenancy, and size ceilings. Returns severity ratings and verification steps.
Intent → Architecture → Plan → Risk → Completion. The submit_for_review contract returns pass/fail gates, prior-decision memory, and structured findings at every stage.
record_decision logs choices with alternatives and reasons. record_outcome closes the loop — "worked" or "failed because...". query_decision_history brings memory into every new review.
Save architecture, requirements, constraints, and coding standards under a short id. Every future review references the pack by id — no more resending large payloads.
One design, multiple reviewers. review_design accepts a reviewers list — security, scalability, performance — and returns one structured review per lens in a single call.
export_review renders any review result as markdown — and can attach a PolyDocs ADR plan for handoff. Review outcomes become decision records in your published docs.
Every review respects your profile — enterprise, startup, or custom. Pass standards and personas to tailor rigor: OWASP sweeps for security, cost curves for scalability, migration concerns for databases.
The governance loop from proposal to institutional knowledge in 4 steps.
The agent submits a proposal through the governance contract — "we chose SQLite over Postgres", an API design, a scaling plan — optionally referencing a saved context pack.
The right lens returns structured findings with actionable suggestions. Challenge Mode then attacks the proposal — surfacing scale shocks, auth compromises, and tenancy leaks before users do.
submit_for_review issues the verdict: pass/fail per governance stage, with prior-decision memory attached. Agents know exactly what to fix before moving to the next stage.
Decisions and outcomes are recorded into engineering memory. Reviews become ADRs via PolyDocs export. The next proposal starts smarter than the last.
Every Archon capability is exposed as an MCP tool. Compatible with every MCP client.
| Tool | Description |
|---|---|
| review_architecture | Review overall software architecture — separation of concerns, data flow, dependencies, abstractions, state management. |
| review_api | Review API design (REST/GraphQL/gRPC/MCP) — naming, consistency, versioning, auth, pagination, idempotency, error envelopes. |
| review_database | Review schema — normalization, indexes, foreign keys, bottlenecks, migration concerns, growth policy. |
| review_scalability | Review scaling behaviour — caching, queues, async, horizontal scaling, SPOFs, cost curve under load. |
| review_security | Security review — auth, secrets, encryption, privilege escalation, input validation, OWASP sweep, compliance. |
| review_design | Multi-lens design review — pass a reviewers list and get one structured review per lens in a single call. |
| review_plan / review_feature / review_tradeoffs | Implementation plans, feature proposals, and technology decisions — pros, cons, long-term impact, enterprise opinion. |
| challenge_proposal | Adversarial Challenge Mode — attack scenarios across scale, corruption, auth, contracts, tenancy, and size limits with severity ratings. |
| submit_for_review | The governance contract — stages: intent, architecture, plan, risk, completion. Returns structured review, pass/fail gate, and prior-decision memory. |
| record_decision / record_outcome | Log architecture decisions with alternatives and reasoning; close the loop with outcomes so future reviews learn. |
| query_decision_history | Search engineering memory by decision text, project, or tags to bring relevant prior decisions into any review. |
| save/get/list_context_packs | Persist architecture, requirements, constraints, and standards under short ids — reference them in reviews without resending payloads. |
| export_review | Render any review as markdown and optionally attach a PolyDocs ADR plan for documentation handoff. |
| archon_status | Engine status — version, LLM provider, enabled review lenses, and governance stages. |
Every stage of the lifecycle has a contract — submit once, get a verdict, move forward or fix.
Should we build this at all? Simplest alternative, complexity, risk, success criteria.
Structure review — concerns, data flow, dependencies, abstractions.
Work breakdown, sequencing, risks, acceptance criteria, rollback.
Adversarial challenge + security sweep before a line of code ships.
Final gate — verdict, memory update, ADR export to PolyDocs.
Archon is hosted at archon.arcflameinteractive.com/mcp. Get a token, configure your client, and go.
// ~/.config/opencode/opencode.jsonc { "mcp": { "arcflame-archon": { "type": "remote", "url": "https://archon.arcflameinteractive.com/mcp", "headers": { "Authorization": "Bearer <your arcflame token>" }, "enabled": true } } }
// ~/.claude/settings.json { "mcpServers": { "arcflame-archon": { "type": "remote", "url": "https://archon.arcflameinteractive.com/mcp", "headers": { "Authorization": "Bearer <your arcflame token>" }, "enabled": true } } }
// .cursor/mcp.json { "mcpServers": { "arcflame-archon": { "type": "remote", "url": "https://archon.arcflameinteractive.com/mcp", "headers": { "Authorization": "Bearer <your arcflame token>" }, "enabled": true } } }
# Bridge any local client to the remote MCP npx mcp-remote https://archon.arcflameinteractive.com/mcp \ --header "Authorization: Bearer <your arcflame token>"
Compatible with Claude Desktop, opencode, Cursor, Windsurf, and any MCP client. Access is issued with your Arcflame token.
Request AccessNine lenses. One challenger. Five gates. Archon reviews everything your agents design — before production finds out.