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.
Add organization member invitation management
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.
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.
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
Package what the run needs.
Requirements stay beside comments, files, screenshots, project conventions, prior gate failures, and repository instructions.
- Ready attachments are snapshotted into the manifest
- Comments and custom fields survive every handoff
- Repository instructions remain inside the repository
Observe real repository work.
The worker claims a run, receives server-owned execution policy, works in an isolated checkout, and emits durable progress events.
- Run lease and worker capacity are explicit
- Every tool step can be inspected
- Failed workspaces can remain available for recovery
Let configured gates decide.
Quality gates are server-owned commands with stable identifiers, timeouts, and required flags. Repositories can override the global gate set.
- Tests, type checks, builds, or custom commands
- Gate evidence is attached to the mission
- Failure returns the work to refinement
Make the human decision informed.
The pull request, changed files, run explanation, gates, and complete retained activity are visible together. Approve, discard, cancel, or request refinement.
- Live GitHub pull-request state
- Human-confirmed merge and discard controls
- Feedback can start a new run with guidance
Close the loop in both systems.
GitHub remains authoritative for code and merge state. RustGrid records the transition, completes the mission, and retains the activity according to the plan.
- Pull request merged in GitHub
- Mission moves to its configured terminal state
- Durable audit and activity remain queryable
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.
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.
Explicit mission boundaries
Project, repository, description, comments, fields, attachments, and instructions travel together.
Scoped workers and credentials
Tenant permissions, worker credentials, repository bindings, and run-scoped GitHub tokens narrow access.
Server-owned execution
Commands, sandbox mode, timeouts, network rules, writable roots, and gates come from the manifest.
Visible human controls
Cancel active work, inspect evidence, add guidance, retry, merge a successful pull request, or discard it.
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.
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.
Add repository installation removal flow
Remove a linked GitHub installation from the project without changing callback ownership or exposing installation credentials to the browser.
Decisions survive the handoff.
Human guidance and agent updates stay attached to the mission instead of disappearing with one execution session.
Visual and written context travel together.
Attachments are captured with the mission snapshot used for the run.
The run starts from repository-owned rules.
RustGrid binds the mission to the selected repository, branch policy, and current project instructions.
Failure becomes input for refinement.
A failed configured gate is durable evidence, not a transient terminal line.
Agents can see the work around the work.
Relations make dependencies and prior implementation decisions explicit.
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
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.
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"
}'const response = await fetch("https://app.rustgrid.com/api/v1/tickets", {
method: "POST",
headers: {
Authorization: `Bearer ${rustgridToken}`,
"Content-Type": "application/json",
"Idempotency-Key": "mission-invitation-management-001",
},
body: JSON.stringify({
project_key: "PLAT",
title: "Add invitation management",
description: "Acceptance criteria: resend, revoke, and cover failures.",
type: "task",
priority: "high",
status: "todo",
}),
});let mission = client
.post("https://app.rustgrid.com/api/v1/tickets")
.bearer_auth(rustgrid_token)
.header("Idempotency-Key", "mission-invitation-management-001")
.json(&serde_json::json!({
"project_key": "PLAT",
"title": "Add invitation management",
"description": "Acceptance criteria: resend, revoke, and cover failures.",
"type": "task",
"priority": "high",
"status": "todo"
}))
.send()
.await?;Execution is a separate, explicit step through the ticket's agent-run endpoints. RustGrid does not invent a /missions contract around the existing API.
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.
“Add invitation resend and revoke actions to member management.”
“Resolve the mobile navigation failure and add regression coverage.”
“Extract repository access into a typed service without changing behavior.”
“Upgrade the framework to its supported version and repair affected tests.”
“Generate API usage documentation from the current implementation.”
“Patch the reported dependency issue and verify the production build.”
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.
Worker identity, scoped credentials, capabilities, heartbeats, capacity, queue replay, leases, and run claims.
availableServer-selected global or repository-specific commands with stable IDs, required flags, and timeouts.
availableRepository binding, required workflows, run-scoped token issuance, PR state, review, merge, and discard flows.
betaThe current reference worker is Codex-centric. Broader agent specializations remain active product work.
in developmentGeneral model and sandbox provider portability is direction, not a current platform guarantee.
plannedReal 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.
/agent-runs/{run_id}/events/stream/agent-runs/{run_id}/manifest/tickets/{id}/quality-gate-results/agent-runs/{run_id}/github-token/agent-runs/{run_id}/pull-request/agent-runs/{run_id}/accept-pull-requestStart 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.
Explore the system
2 projects, 3 users, 100 missions per month in the current ticket contract.
Launch RustGridBuild the workflow
10 projects, 15 users, 5,000 missions per month, custom fields, and 30-day audit retention.
Choose BuilderOperate more work
100 projects, 100 users, higher platform limits, and 365-day audit retention.
Review ScaleDefine the boundary
Annual agreement, tenant-specific limits, custom retention, and contract support.
Contact RustGridYour 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.