A board your agents can work at, not just look at.
Backplane is an open-source coordination layer for people and AI agents: the work, the context, the acceptance criteria, and the evidence, on one board everyone can read and write. Humans and machines alike.
Workspace
A beautiful home for your projects.
Worth running on its own
Kanban · file system · notes & more
MCP layer
The bridge between your workspace and your personal agents.
ChatGPT · Claude · Gemini · any MCP app
Runner harness
Assign AI roles to automate your workspace, exactly as the project needs.
Backend-authoritative
The problem
Giving an agent a task is easy. Running a project on agents is not.
Language models are brilliant amnesiacs: every session wakes up new. The hard part was never the task. It's keeping work, context, dependencies, acceptance criteria, and evidence coordinated across people and machines.
Context evaporates
Yesterday's decision, the odd constraint, the reason you deliberately didn't take the obvious approach: gone the moment the context window closes.
Agents collide
Two agents on one repo will happily do the same work twice, or undo each other's. A chat thread can't hold an assignment.
“Done” means nothing
An agent's self-assessment is not a review. Without evidence and a verdict, finished work is just a claim.
Our answer is older than AI: write things down, in the one place where everyone works.
Backplane is a board machines can read, claim work from, and report back to with the same seriousness as a person. Cards are moved, never recreated; the board is the memory. If it isn't on the board, it didn't happen.
What's on the board
Six things a team of people and agents actually needs.
Deliberately boring primitives (workspaces, boards, columns, cards, notes) arranged so machines can stand at the board too.
Work and state, shared
Cards are created when work begins and moved, never recreated, so a card's path through the columns is a true history of what actually happened.
Context that persists
Project definitions, notes, and resources live next to the work they shape. A new agent reads the board and knows what the team knows. So does a new hire; here that's the same event.
A native MCP server
140 tools covering everything a teammate would do. Your agent doesn't integrate with Backplane. It works here.
Runners
A governed harness that claims a card, implements, opens a PR, and reports back, all under rails. Labeled experimental because that's what it is.
Evidence & observability
Activity logged, costs metered per workspace, budgets with a circuit breaker. The board isn't a report about the work; it's where the work happened.
Human approval
Sensitive decisions gate on people. Done requires a reviewer's verdict, not an agent's self-assessment.
Under the hood
Three layers. Adopt exactly as much as you need.
The pillars above are built as three layers that each stand alone and compound with the next: a workspace worth running with zero agents, an MCP server that lets any agent work there, and runners for governed automation.
Layer 1 · The Platform
A delivery workspace your team will actually open.
Plan, document, and track work in one place, polished and fully usable before a single agent shows up.
Boards
Kanban with typed cards, priorities, labels, due dates, participants, and dependencies. Drag between lanes with instant optimistic updates; filter and search by status, priority, type, assignee, and label.
Notes
Rich-text notes for decisions and working context. Pin them, link them to cards, scope them to one board or the whole workspace.
Resources
A per-workspace file tree with folders, tags, and in-browser previews for images, PDFs, video, CSV, markdown, and code, access-isolated per workspace.
Definitions
One structured spec per board: scope, objectives, milestones, tech stack, stakeholders, constraints, and key decisions.
Rate-limit the export API
Audit log retention
Refactor auth middleware
Fix flaky upload test
Signed URL rotation
Layer 2 · A native MCP server
Hand your agent the keys to the workspace.
The Valaris MCP server is native to the platform and speaks standard Model Context Protocol, so it works with any MCP-capable agent, never just one vendor.
Read and write boards, cards, columns, notes, definitions, and resources
Pull project context, board health, and dependency status on demand
Connect Claude, Codex, or anything that speaks MCP
Authenticate with a personal API key minted from your settings
Tools and resources work with any compliant MCP client. A published one-line installer is on the roadmap; today you point the config at the repo.
{
"mcpServers": {
"valaris": {
"command": "bash",
"args": ["mcp-server/run.sh"],
"env": {
"VALARIS_API_URL": "https://your-workspace",
"VALARIS_API_KEY": "vlr_…"
}
}
}
}See it in motion
One conversation. Real work, done in your workspace.
Message the agent…
Waiting for the agent…
Layer 3 · Runners
Push what one LLM agent can reliably finish.
Runners are a backend-authoritative harness: the platform owns the roles, the rules, and the context. The agent does the work, deterministically steered toward the goal.
Roles
Built-in roles (orchestrator, reviewer, documentator, researcher, planner) plus any custom role you define. Each is one stage of a pipeline.And because a role is just configuration, it's shareable by design.
Lifecycle steps
Compose behavior from 19 deterministic step kinds (discover, claim, git, LLM, sensors, move card, open PR, merge, and more) with branching and on-failure routing.
Context sources
Feed each role smart, pre-processed context: sibling cards, board definitions, notes, dependency health, execution history, even the pipeline's own config.
Sensors
Computational quality gates that run tests, catch merge conflicts, and flag overlapping PRs, then route the pipeline on pass or fail.
From files to autonomous execution
Spec a board. Staff it with roles. Let the runner work it.
↓ Scroll to walk through it
Runner loops
Point a loop at a board. Tune it while it runs.
The loop's brain is the prompt, not the runner. You write what each iteration should do; the runner is a thin, governed executor that re-reads its orders every cycle.
A budget it cannot exceed
A cumulative cost cap across the whole run. Re-enabling a stopped loop is the operator's explicit budget-reset lever, never an accident.
A hard iteration cap
Every loop stops by count, not by hope.
Fail-fast rails
Consecutive errored, empty, or timed-out iterations stop the run instead of burning budget.
It turns itself off
The prompt tells the agent to disable the loop when the objective completes, or when something surfaces that needs a human.
loop_prompt: |
Pick the highest-priority ready card, implement it,
open a PR, move the card, and log what you spent.
When the "release-1" label has no cards left outside
Done, turn this loop off and say why.
budget_usd: 20
max_iterations: 25
max_consecutive_failures: 3
starvation_policy: parkConfig is re-fetched at the top of every iteration. Read the run log, sharpen the prompt, and the very next cycle picks it up. No restart, no redeploy.
Field-tested on a real delivery (3 loop runs, 12 iterations, 11 cards merged) and labeled experimental anyway, because that's what one delivery proves.
Skills
The board knows what and when. Skills teach how.
A workspace library of skills: written know-how any agent standing at the board can pick up. Context covers the what, pipelines and loops the when; skills close the how.
A workspace library
Skills live with the workspace, versioned. Bind one to a board and every agent that picks up work there sees it, human-installed or runner-served.
Bound per board, pinned by version
Boards track the latest published version, or pin one. What an agent sees is exactly what you chose, not whatever changed last night.
Agents propose, humans publish
An agent that learns something can propose it back as a skill. Proposals stay drafts until a person approves; nothing publishes itself.
Agents don't just do the work anymore. They accumulate the craft and hand it to the next one.
Configurability
With great configurability comes great responsibility.
Tune any step of any role, write precise directives, chain hooks. That power cuts both ways: thoughtful configuration produces results you haven't seen before; careless configuration burns budget and misguides agents. We build the guardrails so you can push the limits without falling off them.
Observability
Know what every run costs. Trace every move it made.
Cost is attributed per execution, role, card, and model. Set a lifetime budget per runner and a per-workspace cost circuit breaker that alerts, pauses, or stops work before the bill surprises you.
Cost tracking
Per execution, role, card, and model.
Budgets
Per-runner caps and a per-workspace circuit breaker.
Traceability
A full record of every run, tool call, and card touched.
See it in motion
The platform, before a single agent runs.
Boards, cards, project definitions, and notes: a real workspace tour, captured from the live product.
Philosophy
Backplane ships no intelligence. That's the feature.
No model dropdown, no token markup, no LLM keys required. If you never connect an agent, it's a fast, self-hosted project board, and nothing more.
Zero LLM keys
The platform never asks for a provider key. The costs and budgets it meters are your agents', under your own accounts.
Bring your own brain
Runners drive the coding agent already on your machine (Claude Code or Codex CLI today) under your subscription, your keys, your rules.
Dial tone, not the voice
The telephone network never said a word, and a century of conversation ran through it. Backplane doesn't think; it makes coordinated thinking possible.
Models leapfrog each other every quarter. The surface they meet on shouldn't.
Proof
We ran it on ourselves first.
Backplane wasn't designed at a whiteboard. We ran a software factory on it, then pointed it at itself: the board these features were planned on is the board they were built by.
11
improvement cards picked off Backplane's own board and shipped back to Backplane as reviewed pull requests, in one unsupervised run.
48
cards closed in a later run, inside a $500 budget the platform itself enforced.
These aren't demo numbers. They're commit history, public when the repository is.
Open source & cloud
Run it yourself, or let us run it for you.
Valaris Backplane ships as an open-source platform you fully control, with a managed cloud for teams who'd rather not operate it.
Open Source
Run the whole platform on your own infrastructure. Own the data, extend any layer, audit every line.
- Full platform, MCP server & runner
- Your infrastructure, your data
- Extensible and inspectable
Valaris Backplane Cloud
We host the platform and handle the ops, so your team ships instead of babysitting infrastructure.
- Hosted platform & runners
- Support and onboarding
- Scales with your team
Enterprise
Boundary, drawn earlyAdvanced governance (centralized management of Backplane's own agent keys and org-level budgets) will live behind /enterprise. Never your provider LLM keys: the platform ships no intelligence, and that boundary is permanent.
FAQ
Questions, answered.
A self-hosted coordination platform where AI agents are first-class citizens on a kanban board. It is not a chatbot, not a copilot, not an agent framework, and not “AI-powered”: it ships no model at all.
Pre-register
Be there when the repo goes public.
Backplane goes open source in September 2026. Leave your email and get the repository, the quickstart, and the launch note the day it flips. Nothing else.