Constraints over conversations
RBAC, permissions, repository policy, quality evidence, and immutable activity make rules inspectable. Machine-managed constraint objects and architecture policy expand this foundation.
THE RUSTGRID PLATFORM
Connect what should be built to what actually happened. RustGrid is the execution foundation for the ADD control plane.
THE COMPLETE ADD DELIVERY LOOP
Humans define the outcome and the rules. Agents execute within them. Every change must earn its way through quality gates, and every failure improves the next attempt.
This is the ADD operating model RustGrid is building toward. See the implementation roadmap ↗
PRODUCT OWNER · ARCHITECT · PLATFORM ENGINEER
Version four artifacts with the code: constraints, architecture decisions (ADRs), acceptance criteria, and test & documentation rules. Turn each acceptance criterion into a test before implementation starts.
Ready? A human approves the spec only when every criterion maps to a test. Ambiguous requirements go back for clarification before any execution budget is spent.
ORCHESTRATOR · PLATFORM POLICY
Decompose the spec into tasks, identify dependencies, and assign a budget to each task. Route by complexity, blast radius, ambiguity, and previous gate results.
Use a more expensive model when the task needs it. A human is the final escalation point.
AGENT EXECUTOR · SECURITY OWNER SETS ACCESS
The agent works in a sandbox with short-lived, task-scoped credentials. It implements the change against the acceptance tests, updates documentation, and opens a pull request.
Hard boundary: agents do not merge directly, change gates or pipelines, or receive secrets in prompts.
QUALITY PIPELINE · HUMAN-OWNED POLICY
Progress comes from check results. A failed gate stops the change from advancing.
Return the error to the executor and retry once. If it still fails, move up one tier. Exhausted escalations or ambiguous specs reach the exception engineer. The revised change runs through the gates again.
RELEASE PIPELINE · HUMAN-DEFINED APPROVALS
Only a change that passes the gates and any required human approvals can merge through the controlled release process. Deploy progressively, monitor runtime health, and roll back automatically when rollout checks fail.
Humans govern release rules and sensitive exceptions. The agent cannot approve its own way around them.
HUMAN OWNERS · ROUTING FEEDBACK
Measure cost per delivered spec, first-pass gate rate, escalation rate, spec-to-production lead time, spec rejection rate, and change failure rate.
Exception engineers turn fixes into tests or constraints. Architects approve new ADRs. Platform engineers tune gates and routing; task types that reliably pass can move to a cheaper tier.
Back to the spec ↩ Feed production evidence and failures into the next specification. Human owners approve policy changes; agents cannot rewrite their own rules.
RUSTGRID’S ROLE ACROSS THE LOOP
The control-plane model links every task and change to its approved spec, executor, gate results, cost, and human decisions. That record lets a team explain what shipped, why it passed, what it cost, and who owns the next action.
THE PAPER → THE PLATFORM
RustGrid already provides the deterministic work, identity, concurrency, execution, and evidence foundation. The roadmap completes the spec, gate-state, and cost-routing layers without pretending planned behavior is already live.
RBAC, permissions, repository policy, quality evidence, and immutable activity make rules inspectable. Machine-managed constraint objects and architecture policy expand this foundation.
Durable tasks, comments, attachments, project scope, and repository bindings hold the work record. Approved versioned specs and parent-spec links are phase 2.
Runs and quality results already retain execution evidence. Spec readiness and acceptance-test mapping make tests the admission rule.
Actor and usage telemetry create the cost record. The orchestrator will route by complexity, blast radius, ambiguity, history, and budget.
Quality checks and GitHub delivery evidence exist today. Gate-derived task state makes the pipeline, rather than a dragged card, authoritative.
Tenant-scoped RBAC, worker credentials, idempotency, ETags, leases, and repository-bound access limit actors and protect concurrent writes.
Tasks, runs, steps, sequenced events, activity, quality results, webhook delivery, and GitHub state form one auditable chain.
Failure evidence already survives the run. Root-cause labels, constraint links, learned routing, and per-spec cost close the feedback loop.
FOUNDATION / DESCRIBED IN THE PAPER
RBAC provides a policy foundation for humans and agents.
Handler-level idempotency protects repeat operations.
ETags and If-Match guard concurrent writes.
Tickets and comments retain work and decision context.
Tracing and Prometheus metrics provide an operational base.
HTTP and gRPC transports connect execution surfaces.
THE PATH TO FULL ADD
The paper proposes extending this core with agent principals, scoped leases, a thin MCP surface, approved specs, gate-derived status, and tier routing. These are roadmap items, not a claim that every ADD capability is available now.
Inspect the five phasesTHE NEXT WAY TO BUILD
Start with RustGrid’s execution foundation. Build toward a delivery system governed by specs, gates, and clear ownership.