Skip to main content
RustGrid

THE RUSTGRID PLATFORM

Project management
for an agent workforce.

Connect what should be built to what actually happened. RustGrid is the execution foundation for the ADD control plane.

THE COMPLETE ADD DELIVERY LOOP

From a testable spec
to production. And back.

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 ↗

  1. PRODUCT OWNER · ARCHITECT · PLATFORM ENGINEER

    Write the spec. Make it testable.

    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.

  2. ORCHESTRATOR · PLATFORM POLICY

    Split the work. Choose the lowest capable tier.

    Decompose the spec into tasks, identify dependencies, and assign a budget to each task. Route by complexity, blast radius, ambiguity, and previous gate results.

    • T0 Deterministic tools
    • T1 Small model
    • T2 Mid model
    • T3 Frontier model

    Use a more expensive model when the task needs it. A human is the final escalation point.

  3. AGENT EXECUTOR · SECURITY OWNER SETS ACCESS

    Build inside the boundaries.

    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.

  4. QUALITY PIPELINE · HUMAN-OWNED POLICY

    Prove the change. Six gates, cheapest first.

    Progress comes from check results. A failed gate stops the change from advancing.

    1. StaticFormat, lint, types, constraint policies
    2. SecuritySAST, secrets, dependencies, prompt-injection checks
    3. ArchitectureADR compliance and module boundaries
    4. TestsAcceptance tests and coverage thresholds
    5. DocumentationRequired docs, API reference, changelog
    6. RuntimePreview smoke tests and performance budgets
    If a gate fails ↩

    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.

  5. RELEASE PIPELINE · HUMAN-DEFINED APPROVALS

    Release through policy. Watch the result.

    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.

  6. HUMAN OWNERS · ROUTING FEEDBACK

    Turn the outcome into a better next run.

    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

Keep intent, execution, and proof connected.

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

Every ADD principle has a RustGrid answer.

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.

01

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.

Foundation now
02

Specs are the product

Durable tasks, comments, attachments, project scope, and repository bindings hold the work record. Approved versioned specs and parent-spec links are phase 2.

Phase 2
03

Tests before code

Runs and quality results already retain execution evidence. Spec readiness and acceptance-test mapping make tests the admission rule.

Phase 2–3
04

Minimum viable model

Actor and usage telemetry create the cost record. The orchestrator will route by complexity, blast radius, ambiguity, history, and budget.

Phase 4
05

Gates, not routine reviews

Quality checks and GitHub delivery evidence exist today. Gate-derived task state makes the pipeline, rather than a dragged card, authoritative.

Phase 3
06

Secure by construction

Tenant-scoped RBAC, worker credentials, idempotency, ETags, leases, and repository-bound access limit actors and protect concurrent writes.

Available
07

Everything is traceable

Tasks, runs, steps, sequenced events, activity, quality results, webhook delivery, and GitHub state form one auditable chain.

Available
08

The loop tunes itself

Failure evidence already survives the run. Root-cause labels, constraint links, learned routing, and per-spec cost close the feedback loop.

Phase 2–4

FOUNDATION / DESCRIBED IN THE PAPER

Built on the hard parts.

01

Authorization

RBAC provides a policy foundation for humans and agents.

02

Safe retries

Handler-level idempotency protects repeat operations.

03

Concurrency control

ETags and If-Match guard concurrent writes.

04

Durable work records

Tickets and comments retain work and decision context.

05

Telemetry

Tracing and Prometheus metrics provide an operational base.

06

Programmatic access

HTTP and gRPC transports connect execution surfaces.

THE PATH TO FULL ADD

A foundation today.
A defined implementation path.

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 phases

THE NEXT WAY TO BUILD

Give your agents a system to work in.

Start with RustGrid’s execution foundation. Build toward a delivery system governed by specs, gates, and clear ownership.