For leaders · one sentence
AADM teaches your AI coding tools the same engineering discipline your senior reviewers expect — so the work that lands in main is closer to ship-ready, the first time.
▸ An advisory for teams shipping enterprise software with AI assistance
AI coding agents
are powerful.
They are also
confidently wrong on enterprise code.
The thesis
AADM is the missing layer between your agents and your code: an open standard your engineers read, plus a hosted service your agents load every session.
Every coding tool — Cursor, Claude Code, Windsurf, anything that speaks MCP — reasons the same way about your authorization, your boundaries, and your bar for "done." The model doesn't need to be smarter. It needs a standard.
For engineers · one sentence
A hosted MCP exposes typed tools, doctrine, and gates over Streamable HTTP. Your agents call them every turn — route_lane, fetch_auth, debug_defect.
This page argues the case against unguided loops. If you want the discipline underneath it — the role, the layers, and the two agent loops a senior engineer now owns — read agentic engineering.
The agent isn't dumb.
It's missing a standard.
Every team running unguided coding agents at enterprise scale hits the same three failure modes. They are not random. They are structural.
01
Failure mode
Speculative rewrites
The agent edits before it understands. By the time you read the diff, the original bug is buried under unrelated “cleanup.”
02
Failure mode
Silent authorization drift
Who is allowed to do what quietly relaxes — because the agent had no reference to the rules it was supposed to keep.
03
Failure mode
No shared memory across the team
Three engineers, three IDEs, three styles of agent output. Review queues fill with contradictions.
Same situation.
Two outcomes.
Same agents, same code. The difference is which standard the agent loaded when it started thinking.
01
Case file
A test fails sometimes, not always
Flaky tests are how real bugs hide.
tool · debug_defect
Without AADM
The agent bumps the timeout, asserts the test, and calls it green. The flake ships. Customers find it.
With AADM
The agent stops and gathers evidence before touching anything. Timeout edits are blocked until the real cause is named.
02
Case file
“Refactor auth to use the new session API”
Authorization is the thing you cannot get subtly wrong.
tool · plan_delivery · fetch_auth
Without AADM
The agent rewrites three files across the auth boundary. A control quietly relaxes. You find out at 2 a.m.
With AADM
The agent loads the actual authorization rules from the standard, scopes the work, and writes acceptance criteria before the first edit.
03
Case file
Quarterly compliance attestation
“Trust me, CI is green” is not an audit.
tool · audit_run · sentinel_closure
Without AADM
Someone screenshots a passing pipeline and writes a paragraph. Nobody can trace which control covers which boundary.
With AADM
The agent runs a structured audit pass, attaches evidence to each crossing, and produces language an auditor will actually accept.
04
Case file
A vague bug report lands in the queue
The loudest stack trace is rarely the real cause.
tool · classify_bug · debug_hint
Without AADM
The agent grabs the noisiest file and starts editing. Two days later you discover the defect was upstream.
With AADM
The agent classifies ownership first and routes to the right area before any code changes — recon, then diagnose.
05
Case file
A team using three different IDEs
Same task, three different agent behaviours, three styles in review.
Without AADM
Each engineer's prompts diverge. Quality depends on whoever was at the keyboard. Review gets noisy.
With AADM
One hosted standard, one set of workflows. Every IDE — Cursor, Claude Code, Windsurf, anything that speaks MCP — loads the same lanes and gates.
06
Case file
Onboarding a new senior engineer
“How we do things here” usually lives in Slack threads.
Without AADM
They learn the team's bar from PR comments over six weeks. Until then, their work and the team's drift apart.
With AADM
Their agent loads the same standard the team uses on day one. Their first PR matches the team's discipline.
Three jobs.
Three lanes.
One answer each.
Every coding task is one of three things: building something new, fixing something broken, or proving something is aligned. AADM gives each one its own workflow — so the agent picks the right one, not whichever instinct fires first.
I
Navigator
Building something new
“ Build this feature. ”
Turn a vague ask into a clear, ordered plan — with authorization, ownership, and acceptance criteria baked in before any code is written.
For engineers
UDALI-aware scope, AUTH catalog references, structured slice plan with acceptance criteria per slice.
Tools the agent calls
plan_delivery map_feature fetch_auth slice_issues II
Investigator
Something is broken
“ This is broken. ”
Find what's actually wrong before changing anything. No speculative rewrites, no edits piled on top of guesses.
For engineers
Evidence-first Path A recon. Path B diagnosis gated until failure classification crosses the router threshold.
Tools the agent calls
debug_defect classify_bug debug_hint fix_pack III
Sentinel
Proving it's aligned
“ Prove it's aligned. ”
Show — in language an auditor or compliance lead will accept — that the controls you say you have are actually in place.
For engineers
Audit programs scope seams. Evidence binds per crossing. Closure tiers come back in VERT/HORI language.
Tools the agent calls
audit_run audit_outline sentinel_closure sentinel_stage_guide What actually changes in the loop.
Four small differences on every turn that a raw agent loop never makes. Together they are the gap between “the model shipped it” and “the team shipped it.”
- 01
The right kind of job is picked first
Build, debug, or attest — the agent classifies the question before touching anything. A defect doesn't accidentally get the “build me a feature” treatment.
runs route_lane - 02
Rules come from the source, not memory
The agent reads your authorization rules and boundary definitions directly from the open standard — instead of paraphrasing what it half-remembers.
runs fetch_auth · fetch_seam - 03
Gates stop premature edits
Evidence has to land before a fix can. Timeout bumps, scope creep, and multi-file refactors are blocked until the real problem is classified.
runs debug_defect · Path A → Path B - 04
Every session, every harness, the same standard
Cursor, Claude Code, Windsurf — whatever your engineers run, it loads identical workflows over one HTTP endpoint. Discipline stops being a property of whoever was at the keyboard.
runs Streamable HTTP · /mcp
AADM is governance context, not enforcement.
The hosted service ships versioned workflows, doctrine, and tools your agents load every turn. It does not run your business logic, scan your repository, or replace your CI.
Your production authorization, gateways, tests, and CI stay authoritative. AADM makes sure your agents understand them the same way your senior engineers do.
It deliberately does not
- 01 Run your business logic or mutate your database.
- 02 Issue compliance certificates or legal verdicts.
- 03 Replace code review, CI, or server-side authorization.
- 04 Scan your repo and hand out pass / fail verdicts.
Built for teams where
“the model did it” isn't an answer.
A
Engineering leaders
Your bar for review becomes the agent's bar for output.
Discipline stops being per-engineer. Cursor, Claude Code, contractor laptops — every agent loads the same workflows, controls, and gates. Review feedback gets shorter because fewer things make it to the PR.
B
Platform & DevEx
One hosted service. Wire it once.
Subscribers point any MCP-capable IDE at one Streamable HTTP endpoint. Versioned tools, deterministic routing, capability bumps on your schedule — no per-team prompt sprawl.
C
Security & compliance
Attestation language an auditor will accept.
Audit programs, seam closure, and authorization references give your evidence a structure — without ever claiming the MCP itself “certifies” anything. Your apps and CI still prove enforcement.
▸ The directive
Stop shipping
the wrong thing
faster.
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.
Advisory · Why AADM v1
For · Senior engineering & platform teams
Status · Open standard, hosted MCP