MCP Server

An AI coding agent with no architecture context writes plausible code that duplicates a service you already have, integrates a second way with a system you already integrate with, and satisfies a standard’s wording while defeating its purpose.

None of that is a model failure. It is a context failure: nobody told the agent what exists, or why the rules exist. The MCP server tells it, before the code is written.

Connecting

The server speaks Streamable HTTP MCP at /api/mcp, authenticated with the same API token a pipeline uses. Scope arch:read opens it; add check:run if the agent should be able to grade its own designs.

Claude Code

claude mcp add --transport http archngn https://app.archngn.com/api/mcp \
  --header "Authorization: Bearer angn_prod_..."

Cursor, VS Code, or anything with an mcp.json

{
  "mcpServers": {
    "archngn": {
      "type": "http",
      "url": "https://app.archngn.com/api/mcp",
      "headers": { "Authorization": "Bearer angn_prod_..." }
    }
  }
}

A client that only speaks stdio — use mcp-remote, which does exactly this job and is maintained:

{
  "mcpServers": {
    "archngn": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://app.archngn.com/api/mcp",
               "--header", "Authorization: Bearer angn_prod_..."]
    }
  }
}

The host is per-plane and is shown beside your token in the console.

Tools

Tool	When an agent should reach for it
`search_architecture`	Before writing or changing code that touches an existing service
`get_component`	Before changing a service it did not write — shows what depends on it
`list_standards`	Before choosing a technology, integration style or data-handling approach
`get_standard`	When a summary is not enough to decide whether a design complies
`get_metamodel`	When proposing new components or relationships
`check_design`	Once it has a design, before writing the code — and again before opening a pull request

The catalogue is filtered by scope, so a read-only token never sees check_design at all. Advertising a tool the caller cannot invoke costs the agent a turn and teaches it nothing.

The part that changes what gets written

Every standard reaches the agent with its reasoning attached, not just its rule:

### Integration Standard 4.2 [standard, approved]
- Intent: Keep money movements reconcilable within one transaction boundary.
- Why it exists: Payments reconciliation is audited end-to-end; a synchronous
  call keeps the ledger write inside the caller's transaction.
- If not followed: Event-driven writes need a compensating reconciliation
  process and an agreed eventual-consistency window with Finance.
- Owner: Payments Architecture

An agent told “violates Integration Standard 4.2” learns a rule to route around. An agent told why can do the thing you actually want: comply, propose an alternative that preserves the intent, or raise the trade-off explicitly as a decision to be made.

Where a standard has no recorded rationale, the tool says so and tells the agent to treat the rule as binding but ask its owner before designing around it — which is also a useful prompt to go and write the rationale down.

Checking a design before writing it

check_design runs the same engine your CI pipeline runs, so a design that passes here passes the gate. Its arguments are plain lists an agent can fill straight from its own plan — the component, what it will call, what it will expose, what it will store — because a pipeline ships build artifacts and an agent has none.

Depth defaults to fast: free, instant, and safe to call on every iteration of a design. deep is opt-in per call and adds an AI pass over your written standards, so it belongs at the end of the loop once the design has settled.

See Design Checks for what the engine looks at.

Scoping an agent’s token

Give an agent arch:read only, unless you want it running billable checks — then add check:run. Never check:waive: an agent that can waive the findings it triggers is an agent that never fails a check.

Bind the token to a workspace when the agent works on one system, and mint it separately from your CI token so the two can be revoked independently.

Working without an MCP client

The same context is available from a terminal, for piping into any tool:

archngn context "adding an async refund flow between payments and the ledger"
archngn standards --topic integration

REST API: the same operations over HTTP, for pipelines and applications.
Design Checks: the engine behind check_design.
Reference Library: where the standards an agent reads are authored.
AI Risks: how we think about AI in the platform.