Agent-hub hands tasks to another AI with a five-part summary

You hand a task to another AI agent, copy over the last response—and find yourself explaining what you were trying to do all over again. The response contains the latest result, but may leave out the goal, constraints and reasoning behind decisions already made. Agent-hub has introduced a /handoff command for this transition: the original agent writes a summary, a person reviews it, and the new agent receives the text and continues working. For developers, the useful part is the handoff method itself, which they can reproduce in their own tools.

What the next agent receives

Agent-hub runs agents on a computer and lets users communicate with them through topics in a Telegram group. The /handoff command manages the transition between agents: it first prepares a description of the task's current state, then opens a new topic with the selected recipient after confirmation.

The summary has five parts: the goal, completed work, decisions made, affected files and remaining steps. The original agent is instructed to rely on the known history and explicitly flag gaps. During preparation, it must limit itself to summarizing, without continuing the task or calling tools.

Suppose you are adding a way to retry sending a result after a network failure. One agent has already implemented response persistence and a queue. Another needs to check recovery after a restart. A useful handoff will explain where the changes are and why delivery was designed to resume from the first unacknowledged part. This is a hypothetical example from the article: it illustrates the information that can easily disappear when only the last message is copied.

The summary is limited to 3000 UTF-16 code units. The application rejects empty or overly long text. There is no automatic truncation: the end may contain the next steps or an important constraint. Even a summary within the length limit can omit rejected alternatives and the reasoning behind decisions.

Confirmation is tied to the task's state

Before the receiving agent starts, the user sees the text and can revise it in full or cancel the handoff. Only the person who initiated the process can confirm it. Only then does the application create a Telegram topic, save its association and launch the agent.

The draft is valid for 15 minutes from the moment /handoff is opened. A new turn in the original session, restoring a snapshot, changing the context or settings, or restarting the application invalidates it. Old buttons should stop working, and confirming again should not create a second topic. For developers building agent interfaces, this offers a concrete lesson: user consent must apply to a specific version of the text and a specific task state.

A lost Telegram response is handled separately. The service may have created a topic even though the application received no confirmation. Agent-hub therefore does not automatically retry creation, which could produce duplicates. The author recommends checking the topic list before trying again.

Generating the summary takes a separate turn by the original agent and may consume paid tokens or subscription allowances. Interfaces should account for this: transferring context itself takes time and resources.

Shared files remain a risk

The receiving agent starts a new session in the same project directory. It does not inherit the original agent's history or permissions. A statement in the summary that a command has been approved does not, by itself, replace the confirmation required by the receiving agent's settings.

Both agents can still see the same files. The original topic remains available, so working in parallel can lead to overlapping edits. There is no file isolation or automatic conflict resolution. Files on disk may also change after the summary is prepared: the new agent needs to compare the description with the project's actual state.

The ban on tools during summarization also has limits. A dedicated channel rejects permission requests, questions and file transfers, but, as the author notes, it does not provide a full sandbox. If the CLI independently permits a tool to run, the channel does not guarantee isolation.

According to the author, the scenarios were checked with automated tests using mocked agents and Telegram, followed by manual testing with real agents. The article provides no quantitative assessment of context loss. The practical takeaway is more modest than a promise of a seamless transition: hand over a reviewable account of the task's state, identify unknowns and ask the receiving agent to check the files before editing. The project's source code is available in the repository github.com/aprazdnikov/agent-hub-rs; the author lists an MIT license.