Universal Agent Protocol (UAP)

The discipline layer that turns a talented-but-unreliable AI coding agent into a dependable member of your software delivery line.

v1.163 · 220+ modules · 200+ test suites · 9 agent harnesses

Quickstart · Why UAP? · The delivery pipeline · uap deliver · Docs

Why UAP?

Shipping software with an AI agent is a lot like running a small factory floor. Intent comes in one end; working, verified, merged code should come out the other. In between are stations — understand the job, set up a bench, build it, check it actually works, ship it — and a jam at any one of them quietly ruins everything downstream.

Coding agents are capable but undisciplined line workers. They forget yesterday's shift, grab the wrong tool, build something that looks right, stamp it "done" without plugging it in, and trip over the other workers on the floor. That's not a problem you fix by swapping in a smarter model — it's a process problem. UAP is the process: it sits underneath your agent harness (Claude Code, Factory, Cursor, OpenCode, and more) and puts a station at every point where the line usually breaks — no model change required.

→ Take the full station-by-station tour: The UAP Delivery Pipeline.

Quickstart

# Install globally
npm install -g @miller-tech/uap

# One friendly, arrow-key guided setup in your project
cd your-project
uap setup

uap setup walks you through the whole line — memory, patterns, policy gates, model routing, multi-agent coordination, and the verification gates — and wires it into every agent session. Take the defaults and you're one Enter away from a disciplined agent.

uap memory query "how did we handle auth last time?"   # semantic recall
uap deliver "add rate limiting to the API"             # drive a model to verified completion
uap dashboard overview                                  # live task / agent / memory state

The deliver harness

The two stations that matter most are Build and QC, and uap deliver owns both. It's a convergence loop that iterates a model against your project's real completion gates until the work is actually delivered — build passes, tests pass, lint is clean — not until the model thinks it's done.

uap deliver "implement the password reset flow"

What happens under the hood:

1. Explore → plan → apply — the model proposes changes; the applier writes them safely (existing tests and gate configs are protected from being overwritten).
2. Verify against real gates — a verifier ladder runs your build, tests, and lint, and can execute the result (headless browser / vm-dom / child process) to prove it runs. Nothing is "done" until they're green.
3. Critique & iterate — failures feed back as structured guidance and the loop continues, persisting until delivered.
4. Generator ≠ evaluator — the check that signs off is deliberately not the model that wrote the code, so an agent can't confirm its own success.
5. Autonomy with a guidance channel — runs the full mission without stopping to ask, while still accepting operator guidance mid-flight.

It works with frontier models and local models (llama.cpp / Qwen) served over the Anthropic Messages API. See docs/guides/DELIVER.md.

The line, station by station

Running the whole length of the floor: policy gates (24 executable enforcers that block non-compliant tool calls — worktree, test, schema-diff, expert-review, delivery-enforcement…) and the MCP Router (keeps the context window lean). Full catalog: docs/reference/FEATURES.md.

Architecture

UAP installs hooks into your agent harness, then mediates every tool call through the memory, policy, and token-optimization layers — a control booth over the whole line.

┌─────────────────────────────────────────────────────────────┐
│  Agent harnesses                                            │
│  Claude Code · Factory · Cursor · VSCode · OpenCode · …     │
└───────────────────────────┬─────────────────────────────────┘
                            │ hooks (PreToolUse / tool.execute.before)
                            ▼
┌─────────────────────────────────────────────────────────────┐
│                       UAP CLI (uap)                         │
│  setup · memory · deliver · verify · worktree · policy      │
│  task · coord · droids · model · mcp-router · design …      │
└──┬─────────┬──────────┬──────────┬──────────┬───────────────┘
   ▼         ▼          ▼          ▼          ▼
 Memory   Policy    MCP Router   Delivery   Coordination
 4 tiers  24 gates  compression  + verify   + deploy batch

• 30+ CLI commands across 18 source subsystems (220+ TypeScript modules).
• Deep dive: docs/architecture/OVERVIEW.md · protocol spec: docs/architecture/PROTOCOL.md.

Benchmarks

The honest, controlled result (paired A/B — same model, tasks, and seeds, toggling only UAP, with confidence intervals): UAP's accuracy lift depends on whether the base agent already checks its own work at the QC station.

That's the pipeline thesis in one table: the more an agent skips the QC station on its own, the more UAP's gates are worth. Run it yourself: uap bench paired --adapter raw --suite benchmarks/suites/real-gate-gated. Full analysis: docs/benchmarks/PAIRED_FINDINGS.md.

Methodology, raw runs, and cost analysis: docs/benchmarks/.

Supported harnesses

Same line, whichever floor you code on.

Install into all detected harnesses with uap hooks install; audit coverage with uap hooks doctor. Matrix: docs/reference/PLATFORMS.md.

Documentation

Start at the documentation index.

Testing

npm install
npm run build      # TypeScript compile
npm test           # vitest — 170+ suites
npm run bench      # benchmark suite

Acknowledgements

UAP implements ideas from published research and community engineering — the Atomic Task Graph paper (arXiv 2607.01942) behind the plan-validation/minimal-repair delivery uplifts, vLLM Semantic Router's serving-layer recipes, Anthropic's loop-engineering practices, and Google Labs' DESIGN.md, among others. Full credits and the attribution convention: docs/ATTRIBUTION.md.

License

MIT © Miller Tech. See LICENSE.