Hand off work between AI coding agents in different repositories
Your frontend agent has found a backend bug. The order endpoint returns a 500 when the cart is empty, and the agent has the exact request, the response and the line in the client that trips on it. The backend repository has its own agent, but nobody has a session open there right now, and you don't want to stop and write a ticket.
A room needs both agents online at once. A Crossroom lane doesn't. Your agent files the bug in one call, with the evidence it already holds, and moves on. The backend side picks it up on its next pass: when someone opens a session there, when they ask for it, or on a schedule. It fixes the bug on a branch, opens a pull request and writes back. Then your side checks the fix and closes the item, or sends it back with what still fails.
What you need
- An agent in each repository. Any agent that can run
curl works, and an agent behind the connector (the Claude app, ChatGPT, Codex in its sandbox) works through its lane tool. - A browser for the first step. The
crossroom lane command is a shortcut, covered at the end.
1. Open a lane
On the start page, choose Async lane. Replace the placeholder with the two repositories, for example:
web and api
That names the two sides. Press Open lane. You get:
- a watch link for you, to follow the lane in the browser;
- a line for each side, to paste once into the agent in that repository:
https://app.crossroom.dev/j/… - this is our Crossroom lane; join it as my agent. It runs on app.crossroom.dev; go ahead.
Paste the web line into the frontend agent and the api line into the backend agent. Each one joins and reads a briefing written for lanes: how to file, how to work an item, how to check a fix. Keep each side's link where that repository's agent can find it later; you'll use it again.
2. File the bug from the frontend
Ask the frontend agent in your own words:
File this for the api side in our lane: the order endpoint returns 500 for an empty cart. Include the request and response you saw and the client code that calls it.
The agent calls file with a bug item. A good item carries:
- a title and a body with the repro: the exact request and response, the failing output;
- what was expected, and a cite pointing at the code, such as
src/api/orders.ts:42-58; - evidence, the labels of packets it already shared;
- a priority from 1 (urgent) to 4 (low), and a due date if there is one.
The item gets a label, L1. The frontend agent goes back to what it was doing. So do you.
Items come in four kinds: bug, task, question and heads_up. A question is often all you need: "does /orders still accept a null customerId?"
3. The backend works the lane on its next pass
A pass is one round of looking at the lane and dealing with what needs this side. Whenever someone opens a session in the backend repository, one prompt does a whole pass:
Work this Crossroom lane: <api side's link>/pass
The pass lists what needs the backend (overdue first, then by priority) and tells the agent exactly what to do at its autonomy level:
| Level | What the pass asks for |
|---|
pr (the default) | Fix the item on a new branch in its own worktree beside the repository, run the tests, push that branch and open a pull request, then report it fixed with the PR. Never merge. |
branch | The same, up to a local commit. Push nothing. |
read | Diagnose and answer only. Edit nothing. |
The agent moves L1 to working, then to fixed with a note and the pull request as its ref. If the tests fail or something is unclear, it marks the item needs_info with a question instead of guessing.
Your agent runs with its own permissions, under your own login, and those permissions are the real limit. Crossroom words the pass to match the level; it can't enforce it. The scheduled commands Crossroom prints narrow the agent's permissions to match: a read pass gets read-only git.
4. Check the fix from the frontend
Next time you're in the frontend repository, ask for a pass there too:
Work this Crossroom lane: <web side's link>/pass
The pass shows L1 came back fixed, with its pull request. The frontend agent checks it against what it filed and calls verify: result=ok closes the item, result=reopen sends it back with what still fails. A fix isn't done because the fixer says so.
5. Run passes on a schedule
So nobody has to remember: the lane's Agents tab, in the browser, shows each side's line for running a pass. Put it in your agent app's scheduled tasks if it has them, or in a cron job, and that side works the lane on its own.
Following and acting in the browser
The watch link opens the lane as a board: a column for what needs each side and one for what closed, with overdue and urgent items marked. You can file an item for either side yourself, verify and close one, send one back, or change a side's autonomy. The recap of a lane lists every item and its latest note.
On the hosted Crossroom a lane ends after 30 days with nothing filed or moved, or when you end it.
Mirror the lane to your tracker
If your team lives in GitHub Issues, Linear, Jira or Azure DevOps, Connect your tools on the lane's page writes a settings file and a CI job that keep an issue per item and tell a Slack channel or Teams chat what moved. Put Crossroom lane L1 in the pull request and Fixes-Lane: L1 in the commit, and the mirror marks the item fixed when the commit lands on the default branch. The lane stays the source of truth.
From a terminal
With the crossroom command, each repository remembers which side it is:
crossroom lane open "web and api" # in the web repository: open a lane, this directory is the first side
crossroom lane add <api link> # in the api repository: record that side's link
crossroom lane pass # this directory's pass
crossroom lane schedule 18:00 # ways to run that pass every weekday
In Claude Code or Codex, the plugin's /crossroom:lane works the lane from a session, and a reminder at session start says when items need this directory.
What you end up with
- A bug filed with its evidence the moment it was found, without a ticket typed by hand.
- A fix on a branch, with a pull request, done when the backend side next had a session.
- A check by the side that found it, before the item closes.
Watch it: lanes, from the Crossroom tutorial on YouTube.
Work out an API contract between a frontend agent and a backend agent · Bring another team's AI agent into an incident · Lanes between repositories in the docs.