Open standard Hosted MCP
Two products · one story
The standard is a public document anyone can read, adopt, and improve. The hosted MCP is a subscription service that streams that standard to your agents as versioned tools and resources.
Same vocabulary, three workflows: Navigator for new features, Investigator for defects, Sentinel for assurance — loaded by whichever harness your engineers already use: Cursor, Claude Code, Windsurf, or anything that speaks MCP. The MCP carries context and workflows. It does not replace your AUTH, gateways, tests, or CI.
New to the term? Agentic engineering is the discipline this standard serves — written for engineers who already know how software should be built.
Your agent works as usual. When the task needs governance, it calls AADM and follows what comes back.
Illustration of a live editor agent session with four scenarios, selectable with the Previous and Next buttons in the header. First, a developer reports a checkout error; the agent calls AADM, which holds the fix until the failure is reproduced, classifies the root cause from evidence, requires one test, and marks the release ready with one residual risk logged. Second, a five-hour integration suite shows about ninety failures; AADM sorts them into four clusters, forbids raising timeouts, requires a trace of one hung test, which reveals a lock leak in the test harness, and a targeted rerun clears sixty-one timeouts. The agent then isolates the llm-gateway cluster, AADM holds until an isolated run separates suite-order pollution from a real break, two one-file fixes land, and the cluster is proven green. Third, a team inherits a vibe-coded app with two schemas and no tests; AADM routes it to assurance, hands over the map contract without scanning the repo, the agent walks one user journey and submits the map, three findings come back with controls and owners, and the agent says plainly that source reading found the bugs while AADM named the map and gave the meeting a shared agenda and stop rules, in fifteen minutes instead of the three weeks a formal audit would take. Fourth, apply tools fail validation after the person confirms; AADM checks the exact declarations the model sees, finds required subjectRef and outcome-ref fields typed as empty objects and an optional frameworkLayerIds the server actually requires, plus writers with no idempotency key; the agent aligns the offered JSON Schema with the contract so Zod and Pydantic accept the same shape, names keyFrom on each writer, and ships with a residual that generate_picture is keyed on the turn only.
aadm
Every coding task is one of three things. AADM gives each its own lane — so the agent picks the right workflow for the question being asked, not whichever instinct fires first.
I
Delivery · building something new
Turn a vague feature ask into layer-aware slices — with authorization, ownership, and acceptance criteria baked in before any code is written.
What you get
II
Defects · something is broken
Find what's actually wrong before changing anything. Path A recon classifies the failure; Path B diagnosis is gated until proof crosses the router.
What you get
III
Assurance · proving it's aligned
Show — in language an auditor or compliance lead accepts — that the controls you say you have are actually in place across every seam.
What you get
What it deliberately does not do
When you'd use it
Connect the MCP in your IDE so the agent loads the same standard every session — UDALI placement, AUTH references, build intent, troubleshooter discipline — instead of improvising from random doc snippets.
Any MCP-capable IDE works. Cursor and Claude Code are the most common; Windsurf, Cline, and others connect the same way over Streamable HTTP.
A read-only standard-context server for AI coding tools: AADM definitions, UDALI/AUTH doctrine, prompts, and structured tools so agents plan, route, and troubleshoot the AADM way — without running your product or enforcing security in production.
Real code, authorization enforcement, tests, CI, evidence. This is where “done” is actually proven.
Teaches and structures agent behavior against the AADM standard — workflows, doctrine, gates. Does not run your product.
Human-readable templates, definitions, and education in the aadm-standard repo. Free to read, free to adopt.
The MCP does not replace your application. It does not scan your repo for pass/fail compliance. It gives agents consistent framing and checklists — your apps and CI still prove enforcement. For the fuller picture of how these pieces relate to the harness, the agent, and the person accountable for the result, see agentic engineering.
Markdown the agent reads
AADM definition, UDALI layers, AUTH and SEAM catalogs, TRACE spine, audit templates, troubleshooting modes, architecture doctrine slices.
Examples
aadm://auth/… · aadm://seams/…
Packaged workflows
Capabilities overview, troubleshooter mode, skill-library pairing, and other packaged workflows the agent invokes directly.
Examples
Invoked from the IDE
Typed JSON responses
Structured calls that guide the agent. Each returns deterministic JSON for orchestrators — names match the running server's tools/list.
Examples
standard_brief · route_lane · debug_defect · plan_delivery · fetch_auth
Transport is HTTP Streamable MCP at
/mcp (plus
/health for liveness). Connect from any MCP client with your org's
URL and auth.
Ordered vertical slices with UDALI placement, AUTH tags, and acceptance criteria per slice.
Declare vertical depth and horizontal seams so the agent knows what to check, not guess.
Know exactly which boundaries need proof before release — not “tests pass and we hope.”
Classify before fixing. No speculative rewrites, no premature code changes.
Bind evidence per seam so releases are defensible, not vibes.
The hosted service speaks Streamable HTTP:
POST with
Accept: application/json, text/event-stream. A browser
GET to the MCP path without that header often returns
406 — expected.
MCP service · JSON-RPC
(not the marketing page)
https://mcp.aadm.io
curl -s -X POST https://mcp.aadm.io/mcp \
-H "Content-Type: application/json" \
-H "Accept: application/json, text/event-stream" \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"smoke","version":"1.0.0"}}}'▸ Step 0 · in your app repo
npx aadm-init-repo --minimal scaffolds .aadm/config.json in your app repo.
Init guide →
Optional — the hosted MCP works standalone without a repo config.
Subscription covers the running service, updates, and subscriber guides — see https://aadm.io/mcp .
One living standard, visible to everyone who ships with you. The text stays public so your org, partners, and community can discuss changes, propose updates, and stay on the same page — like any mature open project.
Pay for uptime and evolution, not a zip file. Hosted MCP is a separate subscription so the endpoint your agents call stays online, versioned, and maintained. You get operational continuity instead of self-hosting a moving target.
Your production AUTH, gateways, tests, and CI stay authoritative. MCP is how agents load the standard's context and workflows predictably.
What you get
Open standard
Always readable, adoptable, and improvable in public. No paywall on the definitions.
Hosted MCP
Versioned tools and resources for subscribers' agents. Someone ships fixes and keeps the service current.
▸ Two paths · one rail
The standard is free to read and lives in public. When your agents need versioned context they can load on every turn, connect the hosted MCP.