Skip to content
BACKSTAGE
AI development environment

Your AI team.
Working backstage.

Give your AI agents a real workspace, real tools, and the ability to work together.

Download BackstageExplore Backstage
Worlds

Your workspace. Your world.

A theme decides the room, the palette and who your agents are portrayed as. It decides nothing else — the same team does the same work, wherever you put them.

Detective Office8 characters · same runtime
  • JaneConsultant
  • LisbonTeam Lead
  • ChoTechnical Investigator
  • Van PeltResearch Specialist
  • RigsbyField Agent
  • WainwrightSupervisor

A bullpen, a corkboard, and a team that argues about evidence.

A consulting team, a corkboard, and far too much coffee.

The task

Unchanged. A world has no opinion about what you asked for.

The agents

Unchanged. Same roles, same models, same permissions.

The workflow

Unchanged. Only the room and the cast are different.

The product

See Backstage in action.

Multiple agents. One workspace. Real tools. Real development workflows.

Backstage — product walkthrough
The difference

AI that actually works on your project.

A chatbot hands you an answer and stops. The work — opening the file, running the command, checking whether it broke anything — is still yours. Backstage moves that boundary.

Chatbot

  1. Ask
  2. Answer
  3. Copy
  4. Paste
  5. Terminal
  6. You, still working

Every step after the answer is a person moving text between two windows.

Backstage

  1. Ask
  2. Agents

    the lead breaks it down and delegates

  3. Workspace

    your project folder, on your machine

  4. Files · Git · Terminal

    real tools, real output

  5. Result

    a change in the project, and a diff to approve

The loop closes inside the project. You read the diff instead of assembling it.

Multi-agent

One agent is useful. A team is different.

You cast a team out of the world you chose and nominate a lead. The lead breaks work down, hands pieces to the agents it can reach, and puts the answers back together.

Jane

Consultant

Takes the task, decides the shape of it, and hands out the pieces.

gpt-5 · OpenAI

Cho

Technical Investigator

Reads the project and finds where the problem actually lives.

gemini-2.5-pro · Gemini

Claude

Terminal session

Runs the terminal: installs, builds, and the test suite. Keeps its own name, and borrows a body.

claude code · Local

Lisbon

Team Lead

Reads the diff before anything is committed, and says what is wrong.

gpt-5-mini · OpenAI

Four of the eight in this world. Change the world and the same team is played by a different cast — the roles, the tools and the permissions do not move.

One task, five hands

  1. JANEConsultant

    Takes the task and breaks it into three

  2. CHOTechnical Investigator

    Traces the bug through the project

  3. CLAUDETerminal session

    Writes the fix and runs the suite

  4. LISBONTeam Lead

    Reads the diff and signs it off

  5. JANEConsultant

    Reports back, and queues the follow-up

Who can reach whom

JANEConsultantCHOInvestigatorLISBONTeam LeadCLAUDETerminal

delegate_task · agent_message · team_status — the team tools, exactly as the runtime registers them.

Live transcript

You can read exactly what the team did.

Every turn carries the agent, the model behind it, and the tools that ran. Nothing happens in your project that is not on this list.

Case · expired session accepted
  1. Youdone

    Our login route lets an expired session through once. Find out why, and fix it.

  2. JANEConsultantgpt-5 · OpenAIthinking

    Taking this one. Three pieces: find where the session is checked, find what changed around it, then fix it and prove the fix.

    Cho has the trace. Claude has the terminal.

    • workspace_overviewproject root
    • delegate_task→ Cho, → Claude
  3. CHOTechnical Investigatorgemini-2.5-pro · Geminiworking

    It is in src/auth/session.ts. The refresh runs before the expiry check, so a stale token is renewed and then validated — it passes once, and fails on the next request.

    The order changed in the commit that added silent refresh.

    • filesystem_searchvalidateSession
    • filesystem_readsrc/auth/session.ts
    • git_log-- src/auth
  4. CLAUDETerminal sessionclaude code · Localworking

    Swapped the two calls so expiry is checked first, and covered the token that expires inside the refresh window.

    Suite is green: 84 passed, 0 failed.

    • filesystem_editsrc/auth/session.ts
    • terminal_runnpm test -- auth
  5. LISBONTeam Leadgpt-5-mini · OpenAIreporting

    Read the diff. The fix is right and it is small — four lines and one new test.

    One note: the same pattern is in the API middleware. Worth a follow-up, not part of this.

    • git_diffworking tree
  6. JANEConsultantgpt-5 · OpenAIdone

    Done. An expired session is rejected on the first request now, and there is a regression test for it.

    The commit is waiting on your approval, and Lisbon's middleware note is queued as its own task.

    • git_commitawaiting your approval

A scripted demonstration of a Backstage transcript. The tool names are real; the conversation was written for this page.

Agent activity

  1. JANE

    Task received, split into three

  2. CHO

    Searched the project for validateSession

  3. CHO

    Read src/auth/session.ts

  4. CLAUDE

    Running npm test -- auth

  5. LISBON

    Reviewing the working tree diff

  6. JANE

    git_commit is waiting on your approval

A tool that changes your project stops here and waits for you. Every failure path on that prompt denies.

Real workspace

Your agents can see the work.

Point Backstage at a folder on your machine. Agents orient themselves in it the way a new engineer would — read the manifest, walk the tree, find the entry point — before they change a single line.

  • Reading and writing are separate permissions, per agent.
  • Nothing outside the workspace folder is reachable.
  • Git status and diffs sit alongside the branch you are already on.
Workspace
fix/session-expiry
  • project/
  • src/
  • auth/
  • session.tsM
  • session.test.tsA
  • middleware.ts
  • components/
  • pages/
  • app/
  • public/
  • package.json
Cho · working
  1. Inspecting package.json
  2. Reading src/auth/
  3. Found the application entry point
  4. Located the session check

filesystem_read · filesystem_search · git_log

Claude 1 · terminal
Working

A scripted demonstration. Nothing is executed in your browser.

Terminal

Your terminal. Inside Backstage.

Installs, builds and test runs happen in your project and come back with the output they actually produced. Running commands is its own permission, and a command that changes things waits for you.

terminal_run is a real PTY, not a transcript — so an interactive tool behaves like an interactive tool.

Claude Code is detected before it is launched, so you are told whether it is installed rather than left to read a shell error.

Multi-provider

Bring your models. Build your team.

Each agent is configured with its own provider and model, so a cheap model can do the reading and an expensive one can do the thinking — in the same team, on the same task.

Connected

OpenAI

GPT models, driving any agent on the team.

Your API key

Connected

Google Gemini

Gemini models, connected the same way.

Your API key

Connected

Claude Code

Detected on your machine and run in a real terminal inside Backstage. Your team lead can hand work straight to the session.

Your local install

Coming soon

Anthropic API

Claude models as a directly connected provider.

Coming soon

Coming soon

Ollama

Local models, never leaving the machine.

Coming soon

Coming soon

Mistral

Open-weight models as another provider option.

Coming soon

Different models

Each agent carries its own provider and model.

Different agents

A reader, a builder, a reviewer — same task.

Same workspace

All of them in one project folder, on your machine.

Features

What an agent can actually do.

Every tool below is registered by the runtime and mapped to exactly one permission. The mapping fails closed: a tool with no permission recorded against it is reachable by nobody.

REAL WORKSPACE

Point Backstage at a project on disk. Agents orient themselves in it before they touch anything.

  • workspace_overview
  • filesystem_list
  • filesystem_search

MULTI-AGENT

A team lead breaks work down and hands pieces to the agents you connected it to. They report back.

  • delegate_task
  • agent_message
  • team_status

TERMINAL

A real PTY, not a transcript. Installs, builds and test runs happen in your project and come back with real output.

  • terminal_run

FILESYSTEM

Read and search the project, then create and edit files — reading and writing are separate permissions.

  • filesystem_read
  • filesystem_create
  • filesystem_edit

GIT

Status, diff and log alongside the branch you are already on. Committing is a permission of its own.

  • git_status
  • git_diff
  • git_log
  • git_commit

PERMISSIONS

Every tool maps to a capability, and every agent holds only the ones you granted. Unmapped tools reach nobody.

  • files.write
  • terminal.execute
  • git.commit
How it works

From nothing to a working team, in four steps.

01

CONNECT

Add an API key for the providers you want to use, or point Backstage at your local Claude Code install.

02

CHOOSE

Pick the project folder on your machine, pick a world, and cast the agents who will work in it.

03

DELEGATE

Give the team a task in plain language. Your team lead decides who takes which part of it.

04

SHIP

Watch the work happen — files, terminal, git — and approve anything that changes your project.

Privacy

Your workspace stays yours.

Backstage runs on your desktop, against a folder you pick, with keys you own. The parts of that which are enforced in code are below; nothing else is claimed.

Your workspace stays yours

Agents work in one folder: the project you chose. Reading it, writing to it, running commands in it and committing to it are four separate permissions, granted per agent.

Anything risky stops and asks

A tool flagged as needing approval cannot run until you say yes, and every failure path denies — a timeout denies, a closed window denies, a cancelled run denies.

Keys never leave your machine

Provider keys are encrypted at rest against a key your operating system holds, scoped to the account signed into Backstage. The plaintext stays in the app's main process; the interface only ever learns that a key exists and its last four characters.

No silent fallbacks

A request is made with the key the signed-in user stored, or it is not made. Backstage never reaches for an environment variable, another account's key, or a cached client — the absence of a fallback is the feature.

Model calls go from your machine to the provider you configured, on your key, and are billed to you. Backstage has no server in that path.

Download

Take Backstage with you.

Bring your AI team into your desktop workflow.

Windows

Windows 10 and 11 · x64

Download for Windows

macOS

Apple silicon and Intel

Linux

AppImage · x64

View the source on GitHub
FAQ

Questions, answered straight.

Where the answer is “not yet”, it says not yet.

  • Backstage is a desktop application that gives AI agents somewhere to work. You point it at a project folder on your machine, connect the models you want to use, and cast a small team of agents into a pixel-art workspace. They read the project, run commands in it, and hand work to one another while you watch it happen.

Put your AI team to work.

Give your agents a workspace, connect your tools, and let them build together.

Download BackstageView on GitHub