UmaDev
A coding agent that works like a real dev team: it commands the Claude Code / Codex / OpenCode CLIs you already use and turns a requirement into an evidence-backed, shippable project.
Per-dimension scores and reasoning
Evidence shows substantial governance design: plan/guarded/auto trust dial, always-confirm for irreversible actions, single-writer rule, isolation branch, double opt-in for cloud embedding, credentials kept with the base CLI, audit trail in .umadev/audit. All are README claims; no implementation source was available to verify them. SECURITY.md discloses a real supply-chain incident (malicious npm 1.0.74); hardening followed, but dependency_security cannot be full marks. Deductions are pointed: strong assertions without implementation-level corroboration in the provided files.
Failure messaging is a strength: doctor command, fail-soft degradation (BM25 floor, parked critic failures rather than fabricated acceptance), honest reporting of failed work. Deductions: version badge (1.0.x) vs Cargo.toml (1.1.1) minor inconsistency; dependency availability rests entirely on external vendor CLIs with no local evidence.
capability_boundaries is strong: Plan mode is not advertised as an equal sandbox across vendors, Grok readiness requires a real session, unsupported question surfaces are reported not simulated, role verdicts are advisory. Deductions: cross-vendor drift risk partially mitigated by contract tests in CI; audience/scenario coverage is README-only description.
Information architecture is excellent: full TOC, layered architecture diagrams, a normative spec (UMADEV_HOST_SPEC_V1), trilingual README, thorough install paths (npm/native/source, embedding-model handling) and MIT LICENSE. Deductions: CHANGELOG content, FAQ, and maintenance responsiveness are not visible in provided files; the 1.0.74 npm incident shows the release chain was previously compromised, so maintenance responsibility carries a proven risk despite the stated contact.
Marginal value is real: no duplicate model endpoint; it adds planning, a deterministic acceptance floor, evidence packs, and quality gates to existing CLIs. Deductions: output usability and cost-benefit rest on claims (TUI, proof packs) not verifiable statically; governance-heavy flow's cost control for small tasks is only asserted via depth scaling.
Claim traceability is decent: clause/check counts, CI pinned to commit hashes and SHA-256s, public hashes of the malicious package. Deductions: many strong assertions (fail-closed boundaries, memory quarantine) cannot be cross-checked within the provided files; some marketing language blends vision with fact, though factual vs. aspirational content is mostly separable.
- A real supply-chain incident occurred: npm [email protected] was confirmed not built from this repository and contained an install-time malicious payload. Install only from the official registry at version >=1.0.75 and avoid third-party mirror caches.
- Trust tiers and sandbox strength are not uniform across the five base CLIs; Plan mode is not a hard sandbox. Verify the actual permission surface of your chosen backend before use.
- This is a static review: extensive governance claims (113 checks, fail-closed boundaries, memory quarantine) are unverified within the provided files; audit key paths yourself before adoption.
- Publisher identity is unverified; the maintenance contact is a personal QQ email. Verify the legal entity before enterprise procurement.
What does this agent do, and when should you use it?
UmaDev is an open-source (MIT) coding agent written in Rust that owns no model endpoint of its own; instead it drives one of five first-class backends — Claude Code, Codex, OpenCode, Grok Build, or Kimi Code — and the model behind the selected base is the brain. Its core capability is role-based team orchestration: a nine-seat team (eight specialists plus a coordinator) collaborates through shared blackboard artifacts and structured RoleVerdicts, with writing roles driving a serial single-writer main session and reviewing roles running in parallel on fresh read-only sessions. The normative source of truth is UMADEV_HOST_SPEC_V1 (34 clauses), backstopped by 113 governance content checks covering leaked secrets, emoji icons, hardcoded colors, and AI-slop UI patterns. A full build expands into a nine-phase flow — clarify, research, PRD/architecture/UI-UX docs, plan, frontend, preview, backend, quality gate, delivery — producing on-disk documents, source, runtime-proof., a proof-pack zip, a scorecard, and SOC 2 / ISO 27001 / EU AI Act compliance mapping. It fits engineers and teams who need an auditable delivery pipeline rather than ad-hoc code generation.
You submit a requirement via the umadev chat TUI or umadev run "<requirement>" --backend <id>. The coordinator first routes intent (Chat / Explain / QuickEdit / Debug / Build), clarifies ambiguities, and sizes the work. Heavy builds enter the nine-phase delivery chain: research merges web search with the local knowledge corpus into output/<slug>-research.md; three core documents (PRD with EARS acceptance criteria, architecture with openapi.*, UI/UX) are drafted; a dependency plan is written to .umadev/plan. and rendered as a live checklist steerable with /plan. Frontend and backend writer roles drive the base CLI serially (single-writer), with every file passing the 113-check governance hook at write/commit time. The umadev-contract crate parses the architecture doc's API table into OpenAPI and cross-validates every fetch/axios call in the frontend. The quality gate independently runs build, test, lint, contract check, and a runtime probe (umadev verify --runtime writes runtime-proof.). Deliverables include release/proof-pack-*.zip, scorecard-*.html, and compliance mapping (umadev report). Retrieval is local-first: pure-Rust BM25 is the lexical floor, with optional local vectors (multilingual-e5-small via the candle backend) fused through RRF; cloud embeddings require both OPENAI_EMBED_KEY and UMADEV_ALLOW_CLOUD_EMBED=1. Audit evidence lands as JSONL in .umadev/audit/. UmaDev also runs as an MCP server (umadev mcp serve) exposing governance to other tools.
- A solo developer with an existing Claude Code or Codex subscription wants a full requirement (e.g., 'a todo app with a Postgres backend') turned into a project with PRD, acceptance criteria, and delivery evidence rather than scattered snippets.
- A team needs mandatory pre-landing checks for leaked secrets, unsafe constructs, and template-like UI in AI-generated code, with the evidence chain mapped to SOC 2 / ISO 27001 controls.
- An engineer onboarding an existing (brownfield) codebase uses
umadev adoptto detect the stack, index source, and reverse-derive the API contract before incremental changes. - A team needs unattended, auditable builds in CI via
umadev runwith--mode auto, plusumadev cigovernance scans over every source file. - A developer making a small fix wants to avoid convening the full team: the router sends bugfixes down a light path, and
/quickforces the lean track for trivial changes. - Users of ACP v1 backends like Kimi Code or Grok Build want the same orchestration and governance experience as the other three bases.
What are this agent's strengths and limitations?
- Differentiator: nine-seat role orchestration instead of single-turn prompting — reviewing roles run in isolated sessions and return structured RoleVerdicts, communicating only through shared artifacts and verdicts to avoid context cross-contamination.
- Trust rests on a deterministic acceptance floor: build/test/lint, contract cross-validation, and a runtime probe are checked independently of model self-assessment, and failed work is reported honestly rather than certified complete.
- 113 governance checks + 34 spec clauses + JSONL audit trail + SOC 2 / ISO 27001 / EU AI Act compliance mapping form a rare, complete governance layer for adopting AI coding in enterprise settings.
- Local-first retrieval (pure-Rust BM25 floor, optional vectors) with a bundled knowledge corpus — no cloud knowledge service required, and cloud embeddings need a two-part explicit opt-in so nothing uploads by default.
- A single Rust binary under MIT, shipping prebuilt for macOS (Apple Silicon/Intel), Linux (x86_64/ARM64, glibc/musl), and Windows x86_64, with both npm and sudo-free native installers.
- Strong external dependency: you must have one of the five supported CLIs installed and authenticated; UmaDev ships no model, and offline mode only produces TODO-filled templates, not real code.
- Adoption overhead is real: the full nine-phase flow is significant for simple tasks, and you must understand trust tiers, confirmation gates, and the audit artifacts.
- ACP backends (Grok Build / Kimi Code) have documented capability gaps: Grok uses a bounded fresh-session handoff today (persistent resume stays disabled until sandbox attestation), and only Codex offers verified same-turn turn/steer — the others queue or reject active-turn input.
- Source builders must provision the local embedding model themselves (
--features vector-localplus config./tokenizer./model.safetensors) or retrieval degrades to BM25-only; NFS/SMB and cross-identity write-lock scenarios are unsupported. - Critic verdicts are advisory only, and a missing required review parks the run rather than passing or failing it — the user has to handle parked runs explicitly.
How do you install or deploy this agent?
Option 1 (npm): npm i -g @umatech/umadev, then run umadev; if you hit permission or PATH errors, run umadev doctor for the exact fix. Option 2 (native installer, no Node/npm/sudo): on macOS/Linux run curl -fsSL https://umadev.goder.ai/install.sh | bash; on Windows PowerShell run irm https://umadev.goder.ai/install.ps1 | iex. Use UMADEV_VERSION and UMADEV_INSTALL_DIR to pin version and directory. You also need at least one base CLI installed and logged in, e.g.: npm i -g @anthropic-ai/claude-code && claude auth login, or npm i -g @openai/codex && codex login, or npm i -g opencode-ai && opencode auth login, or Grok Build (curl -fsSL https://x.ai/cli/install.sh | bash + grok login), or npm i -g @moonshot-ai/kimi-code && kimi login (Node.js >= 22.19). Source build: git clone https://github.com/umacloud/umadev.git && cd umadev && cargo build --release --features vector-local (Rust 1.88+; local vectors additionally require placing compatible model files yourself).
How do you use this agent?
Run umadev to launch the chat TUI; the first run lets you pick a base. Just type a requirement (e.g., 'add CSV export to the reports page') for automatic routing, or use /run <req> for an explicit full build, /quick <task> for the light path, and /goal <objective> to keep working until the goal is met. Key commands: /plan to view and steer the live plan, /continue to approve a gate or retry a parked review, /mode plan|guarded|auto to switch trust tiers, /preview to open the frontend dev server, /verify for a conformance report, /doctor for self-tests. Scripted use: umadev run "<requirement>" --backend claude-code --mode guarded (pauses at the docs_confirm gate), umadev continue to approve gates, umadev deploy --run to deploy and write deploy-proof., umadev report for compliance mapping. Note that irreversible actions (merge/reset, deletes, deploys, pushes) always require confirmation on every tier, and UmaDev never merges or pushes on its own.