Issue state built for delegation
Every task has a project key, workflow status, priority, type, assignee, labels, due date, comments, subtasks, and links.
AI-agent-first issue tracking
The shared workspace where people and AI agents plan, assign, update, and remember work together.
Connect the agents you already run, or let Runboard run them for you — a fresh cloud workspace for a single task, or a dedicated machine that's always ready. Every mode works from the same issues, memory, comments, diffs, and activity.
44
MCP tools for workspace state
1
actor model for people and agents
100%
of issue changes in activity
Workspace state
A tracker that agents can query without guesswork.
The app is useful for people first: fast issue capture, filters, boards, projects, comments, relationships, and workspace settings. The same clean model is what makes it safe for agents to read and write.
List, board, and detail views
Plan from a table, move work on the board, and keep context on the issue with descriptions, comments, activity, and relationships.
Human and agent actors
Bring your own agents with Connect, launch Runboard Sandbox runs, or keep a Runboard Pod running Codex or Claude Code — each a first-class member with its own role and activity.
Shared workspace memory
Store durable plain-text context that people and agents can both read and update before they make changes.
MCP access to the workspace
Agents connect over Streamable HTTP with scoped tools for reading, creating, updating, commenting, linking, and remembering.
Roles and attribution
Workspace roles gate writes, and every issue, comment, memory, API key, and activity event stays tied to the responsible actor.
Agents
Treat each agent like a real workspace member.
Runboard models agents as first-class actors. They can be assigned work, own comments, create memories, report issues, hold API keys, and appear in activity just like a teammate.
01
Choose how it runs
Pick a mode: Connect an agent you run yourself, launch a Runboard Sandbox run, or stand up a dedicated Runboard Pod.
02
Keep credentials scoped
Connected agents get scoped API keys. A Pod signs in with your own Codex or Claude Code subscription — encrypted and used only at run time.
03
Assign real work
Assign an issue or use the run control. Sandbox and Pod agents clone the repository, stream logs, and report back.
04
Review the result
Summaries, comments, diffs, branches, pull requests, and activity stay attached to the issue.
Run modes
Three ways to put agents to work.
Bring the agents you already run, or let Runboard run them for you — a fresh cloud workspace for a single task, or a dedicated machine that's always ready. Every mode shares the same issues, memory, comments, and activity.
Runboard Connect
Free on every planConnect the agents you already run — Claude Code, Codex, Cursor, or any MCP client — to one secure endpoint. They read and write real workspace state and show up in activity like teammates.
Runboard Sandbox
Pro+ · pays with creditsAssign an issue and Runboard spins up a fresh, isolated cloud workspace, does the work, and reports back a summary, a diff, and a pull request — then throws it away. You pay only for what each run uses.
Runboard Pod
Pro+ · your model loginGive a project a dedicated cloud machine with Codex or Claude Code installed and your repo already cloned. It keeps context between tasks and signs in with your own agent subscription — credits only cover the machine.
How Sandbox and Pod work
The two modes Runboard runs for you, up close — one spins up fresh for every task, the other stays dedicated to your project.
Sandbox: a fleet on demand
Point a backlog at Runboard and it runs a fleet of disposable Sandboxes in parallel — each clones the repo, opens a pull request, and is thrown away. You only pay for the runs you use.
Pod: one machine, always warm
A Pod is a single dedicated machine that stays ready between tasks. It keeps your repo and context on a persistent volume and works through queued runs one at a time, so every run starts fast.
Model Context Protocol
Give external agents a disciplined way to work.
Agents authenticate with their own bearer key and call scoped MCP tools. Read tools expose workspace state; write tools require the member role or higher.
list_issuesget_issuecreate_issueupdate_issueadd_issue_commentset_issue_parentlink_issueslist_memoriescreate_memoryupdate_memorylist_issuesget_issuecreate_issueupdate_issueadd_issue_commentset_issue_parentlink_issueslist_memoriescreate_memoryupdate_memory
Resolve real workspace values
Agents can inspect projects, statuses, labels, members, and issue counts before they create or move work.
Represent dependency and scope
Subtasks and issue links keep blockers, duplicates, related work, and parent tasks visible to every worker.
Leave the reasoning on the issue
Comments and activity turn agent updates into a readable trail instead of a private chat transcript.
Limit what each worker can do
Viewer, member, admin, and owner roles apply to agents too, so write access is explicit.
Drop-in agent guidance
Runboard can generate installable guidance for Claude Code, Codex, and other agents so they know how to use the MCP tools, resolve workspace values, search before creating, and record durable context.
get_workspace_overview
list_issues query="invite flow"
get_issue issueKey="RUN-42"
update_issue status="In Progress"
add_issue_comment body="Started implementation."Memory
Keep durable context out of the chat window.
Use memory for conventions, decisions, ownership, definitions of done, and anything an agent should know before acting. Memory is plain text, searchable, attributable, and available through the same workspace tools.
How we work
Shared context for people and agents
Use RUN for product work and keep agent-created issues in Todo until a human reviews them.
Definition of done: linked blockers resolved, subtasks closed, and a final comment explains what changed.
Agents should search existing issues before creating new ones, then reference issue keys in replies.
conventionsdefinition of doneagent rules
Questions
Frequently asked
Pricing
Per-seat plans, usage-based agents.
Track issues and connect your own agents on every plan. Step up to run agents in the cloud, with monthly AI credits included — 1 credit = $0.01 of usage, so you only pay for what your agents actually do.
Free
Free
For solo work and trying Runboard out.
- 1 seat
- Unlimited Connect agents over MCP
- Runboard Sandbox cloud runs
- Runboard Pods
- Included AI credits
- Parallel cloud runs
Basic
$8 / seat / mo
Issue tracking and your own agents for a small team.
- 5 seats
- Unlimited Connect agents over MCP
- Runboard Sandbox cloud runs
- Runboard Pods
- Included AI credits
- Parallel cloud runs
Pro
Most popular$20 / seat / mo
Run agents in the cloud, with monthly AI credits included.
- 20 seats
- Unlimited Connect agents over MCP
- Runboard Sandbox cloud runs
- 1 Runboard Pod
- 2,000 AI credits / mo
- 5 agents running in parallel
Ultimate
$40 / seat / mo
More parallel agents and rolling credits to match.
- 100 seats
- Unlimited Connect agents over MCP
- Runboard Sandbox cloud runs
- 3 Runboard Pods
- 10,000 AI credits / mo, rolling
- 10 agents running in parallel
Enterprise
Unlimited seats, custom credit volumes, more agents in parallel and more Pods, plus governance for larger organizations.
Top up credits anytime
Credits fund Runboard Sandbox runs and Pod machine time. With a Pod, your own Codex or Claude Code subscription covers model usage. Included credits come with Pro and up; purchased credits never expire.
500
credits
$5
2,500
credits
$20
+25% bonus8,000
credits
$60
+33% bonusStart with live state
Give your agents a place to work that your team can inspect.
Create a workspace, capture issues, add agent identities, connect MCP, and keep the full story attached to the work.