Skip to content
RustGrid
GitHub issue to pull request

Turn a GitHub issue into a tested pull request.

Install RustGrid, create a project, connect your GitHub repository, and choose an issue. RustGrid runs it as a mission and opens a pull request for you to review.

Install → create a project → connect GitHub → run an issue.

illustrative / mission RG-184 Mission created
RG-184 · rustgrid/rustgrid-agentops

Add organization member invitation management

running
Define
Context
Execute
Change
Validate
Review
Live activitySSE live
Mission createdacceptance criteria · project · priority
Context snapshot lockedcomments · files · repository policy
Frontend Engineer claimed runbranch agent/add-invitation-management
Repository files changedMembersPage.tsx · member-hooks.ts · tests
Configured gates resolvedtypecheck · unit tests · build · a11y
Pull request openedsummary and changed-file evidence attached
Human decision requestedmission status awaiting_review
01 / MISSIONOutcome, not a promptScope, criteria, context, repository, and constraints persist.
02 / RUNWork, not chatAn agent executes against the real repository in a controlled environment.
03 / GATESEvidence, not confidenceConfigured checks decide what is allowed to move forward.
04 / REVIEWAutonomy, not abdicationHumans merge, refine, discard, or cancel with full run history.
The execution gap

Your backlog should not be a waiting room.

Planning tools describe work. RustGrid carries it through execution. Your existing system can keep the roadmap; RustGrid takes structured engineering intent from ready to review.

Work describedwaiting
RequestBacklogPlanningAssignmentContext transferImplementationReview
Work executedobservable
MissionAgent runQuality gatesPull requestHuman decision
One continuous system

From mission to merge.

Explore the same mission as it gathers context, becomes a run, produces repository changes, passes configured validation, and reaches a human decision.

01 / DEFINE

Give the work boundaries.

A mission begins with the outcome, acceptance criteria, project, repository, priority, and the agent that should perform the run.

  • Durable scope instead of a disposable prompt
  • Project and repository boundaries
  • Clear handoff into execution
New missiontodo
Add repository installation removal flow
Require confirmation, revoke the binding, surface failures, and refresh installation state.
Developer Platform
High
acme/platform-console
Senior Full-Stack Engineer
Control Room

See the whole software factory.

RustGrid gives operators one place to see worker health, active and queued runs, lease risk, outcomes, and where human attention is required.

Illustrative product viewLive fleet · Developer Platform
Project: AllWorker: AllStatus: ActiveSearch missions
Workers online4 / 5one worker draining
Active runs7within advertised capacity
Queued runs12durable work available
Run success92%illustrative window
Sequenced runs & logslive
Invitation managementRG-184 · platform-console
runningfrontend-0202:18
Repair mobile navigationRG-179 · marketing
reviewfull-stack-0308:41
Upgrade API clientRG-177 · sdk
failedbackend-0112:06
Document webhook retriesRG-173 · docs
succeededdocs-0104:52
Controlled autonomy

Autonomy without abdication.

Agents move quickly inside the repository, execution policy, credentials, quality gates, and review boundaries you define. Failure becomes a visible state, not a hidden guess.

RUN / 01runningAgent implementsScoped mission. Isolated checkout. Server-owned manifest.
GATE / REQUIREDfailedTypecheck rejectsThe mission moves to needs_refinement with gate evidence.
HUMAN / GUIDANCErefineReviewer directs“Keep the public hook signature backwards compatible.”
RUN / 02retryAgent correctsA new attempt starts with the durable mission and feedback.
REVIEW / READYpassedHuman decidesMerge or discard after the required checks resolve.
Scope

Explicit mission boundaries

Project, repository, description, comments, fields, attachments, and instructions travel together.

Identity

Scoped workers and credentials

Tenant permissions, worker credentials, repository bindings, and run-scoped GitHub tokens narrow access.

Policy

Server-owned execution

Commands, sandbox mode, timeouts, network rules, writable roots, and gates come from the manifest.

Decision

Visible human controls

Cancel active work, inspect evidence, add guidance, retry, merge a successful pull request, or discard it.

GitHub-native execution

Built around how software actually ships.

GitHub remains the source of truth for code. RustGrid becomes the source of truth for autonomous work: the mission, run, policy, evidence, and review state around every change.

Repository lifecycle
GitHub App installedtenant-bound installation verified
Repository linkedacme/platform-console · required workflows set
Branch and pull request createdstructured github_pr external link recorded
Required workflows passedmission → awaiting_review
Human reviewmerge · discard · request refinement
Mission Context

Agents fail when context falls apart.

Prompts disappear. Mission context persists. Every run starts from durable work state and repository-owned instructions, not a chat window that forgets the engineering system around it.

MISSION CONTEXT / SNAPSHOT 02

Add repository installation removal flow

Remove a linked GitHub installation from the project without changing callback ownership or exposing installation credentials to the browser.

Confirmation is required. Deletion uses the current repository-binding ETag. Errors retain their request ID. The visible list reconciles after success.
High
Preserve the public hook signature.
RustGrid Core

Serious work needs durable infrastructure.

The interface is only the visible layer. Underneath it is a stateful, multi-tenant control plane for coordinating humans, agents, permissions, workflows, execution, and retained history.

  • Rust services with HTTP and gRPC interfaces
  • PostgreSQL persistence, idempotency, ETags, and request IDs
  • Tenant isolation, scoped permissions, API keys, and worker credentials
  • Durable queues, event replay, SSE streams, webhooks, and activity trails
Inputs
HumansAPI clientsIntegrations
Control plane
MissionsProjectsAgentsRunsQuality gatesPermissionsActivity
Execution
WorkersIsolated checkoutsGitHub App
Outputs
RepositoriesPull requestsCI workflowsReview state
API-first foundation

Build your own experience on RustGrid.

RustGrid exposes the primitives that power its own interfaces. Public product language calls the work a mission; the current backend resource remains /api/v1/tickets.

POST /api/v1/tickets
curl -X POST "https://app.rustgrid.com/api/v1/tickets" \
  -H "Authorization: Bearer $RUSTGRID_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: mission-invitation-management-001" \
  -d '{
    "project_key": "PLAT",
    "title": "Add invitation management",
    "description": "Acceptance criteria: resend, revoke, and cover failures.",
    "type": "task",
    "priority": "high",
    "status": "todo"
  }'

Execution is a separate, explicit step through the ticket's agent-run endpoints. RustGrid does not invent a /missions contract around the existing API.

Engineering missions

One control plane. Many outcomes.

Give agents bounded engineering work with a verifiable output. Every scenario uses the same mission, run, gate, pull-request, and review primitives.

Product delivery
“Add invitation resend and revoke actions to member management.”
AGENT FrontendOUTPUT Pull requestVALIDATE Tests + build
Bug fixing
“Resolve the mobile navigation failure and add regression coverage.”
AGENT Full-stackOUTPUT Fix + coverageVALIDATE Configured gates
Refactoring
“Extract repository access into a typed service without changing behavior.”
AGENT BackendOUTPUT Refactor PRVALIDATE Existing suite
Maintenance
“Upgrade the framework to its supported version and repair affected tests.”
AGENT PlatformOUTPUT Upgrade PRVALIDATE Build + tests
Documentation
“Generate API usage documentation from the current implementation.”
AGENT DocumentationOUTPUT Docs changeVALIDATE Links + examples
Security remediation
“Patch the reported dependency issue and verify the production build.”
AGENT PlatformOUTPUT Patch PRVALIDATE Configured scan
Extensibility, with status

Bring your workers. Define your rules.

RustGrid exposes worker and policy primitives today while keeping future provider choices honest. Capabilities are labeled by their current state.

Registered workers

Worker identity, scoped credentials, capabilities, heartbeats, capacity, queue replay, leases, and run claims.

available
Repository quality gates

Server-selected global or repository-specific commands with stable IDs, required flags, and timeouts.

available
GitHub lifecycle

Repository binding, required workflows, run-scoped token issuance, PR state, review, merge, and discard flows.

beta
Additional worker adapters

The current reference worker is Codex-centric. Broader agent specializations remain active product work.

in development
Provider-neutral execution

General model and sandbox provider portability is direction, not a current platform guarantee.

planned
Contract-backed product proof

Real primitives. Inspectable contracts.

RustGrid already exposes durable agent-run events, server-owned execution manifests, quality-gate results, run-scoped GitHub tokens, live pull-request state, and human merge or discard actions. The examples above are illustrative; these endpoints are current.

GET/agent-runs/{run_id}/events/stream
GET/agent-runs/{run_id}/manifest
POST/tickets/{id}/quality-gate-results
POST/agent-runs/{run_id}/github-token
GET/agent-runs/{run_id}/pull-request
POST/agent-runs/{run_id}/accept-pull-request
Current platform plans

Start building autonomous delivery.

Current plans meter RustGrid's platform primitives. Live billing and entitlements remain authoritative; agent-run and concurrency pricing is not invented here.

Free

Explore the system

€0 / month

2 projects, 3 users, 100 missions per month in the current ticket contract.

Launch RustGrid
Scale

Operate more work

€899 / month

100 projects, 100 users, higher platform limits, and 365-day audit retention.

Review Scale
Enterprise

Define the boundary

Custom

Annual agreement, tenant-specific limits, custom retention, and contract support.

Contact RustGrid
The next mission

Your next mission does not need to wait.

Connect a repository, define the outcome, and let RustGrid turn intent into reviewable code.

Built in Rust. Designed for agents. Controlled by humans.