Coordinating several agents
Running one coding agent is a conversation. Running three, on two machines, is a coordination problem: who is doing what, what did the last one decide, and how does the next one pick up without you pasting context between windows. Fibonna gives every agent you connect one place for the work (tasks and sprints), one place for the state (handoffs), and a way to start another agent on a task and wait for it.
The unit of work: tasks and sprints
A sprint is a goal with a list of tasks. A task is one piece of work with a status: to do, in progress, blocked, done. Your agent creates them in plain words ("turn this plan into tasks") and updates them as it goes, so the list reflects what happened rather than what you remembered to write down.
When a session starts work on a task, it sets its focus to that task. From then on, every note it saves and every handoff it writes lands on that task, and a later question about the task finds them.
Hand off and resume
At the end of a session, "hand off" writes a handoff: what changed, what was decided, what comes next. It is saved to the project, on your stack, not in the window you were working in.
At the start of the next session, the agent loads it. That session can be on the same machine or another, in Claude Code or any other tool you have connected. "Pick up where we left off on the invoice export" returns what was decided, what is done and what is still open, with the notes it came from.
This is the difference between a handoff and a chat history. A chat history is a transcript in one tool. A handoff is a written state that any agent can start from.
Dispatching a worker
Some work is better given to another agent than done in your own session. Fibonna can start a worker: a second agent session, on a task, on its own branch, so it cannot disturb what you are doing. Dispatched sessions run on a Mac you have paired with npx fibonna.
From your own session you can:
- start a worker on a task: "start a worker on the upload bug";
- check what it is doing;
- wait until it finishes or needs you, so your agent does not keep polling;
- send it an instruction mid-way;
- stop it.
When the worker finishes, it writes a handoff like any other session. Your agent reads it, and the task's status and notes are already up to date.
A day with two machines
Morning, laptop. You start a session on the project. It loads yesterday's handoff and the open tasks. You plan the day in conversation and the agent turns the plan into tasks.
You start a worker on the desktop for the data migration and keep the API change for yourself. The worker runs on its own branch. While you work, your agent waits on it in the background.
The worker finishes and hands off. Your agent reads the handoff, sees the migration needed one extra index, and adds that to the API task's notes. You finish the API change and hand off.
Evening, desktop. You open a session. It loads both handoffs. Nothing is explained twice.
What coordination is not
It is not a project tracker you fill in by hand. Your agents write the tasks, the status and the handoffs as a side effect of working.
It is not a cloud runtime. Your agents run on your machines, with your own API key. Fibonna holds the memory and the state they share.