osFoundry / Platform
Handoffs
When one agent finishes its part, it hands off to the next with full shared context.
What it is
Handoffs let a multi-step task move from one AI agent to the next without starting over each time. When an agent finishes its part of the work, it passes the baton to the next agent along with the full shared context — the conversation so far, the intermediate results, the files and decisions the earlier agent produced. The receiving agent picks up warm instead of cold, so you never re-paste a brief, re-explain a goal, or lose the state that got built up two steps ago.
Inside osFoundry, agents run together in one workspace, so a handoff doesn't cross a tool boundary — the context stays in the same place the whole chain runs. Because osFoundry is bring-your-own-key and model-agnostic, each agent in the sequence can run on a different model: a local model for a private or sensitive step, a cloud model for heavy reasoning, a self-hosted endpoint for something in between. The shared context travels between them regardless of which model each agent uses, and because osFoundry is local-first, that context can stay on your device rather than being copied out to a third-party orchestrator.
This matters because most real work isn't one prompt — it's research, then drafting, then review, then a final pass, often with different strengths needed at each stage. Handoffs turn that into a single continuous run instead of a manual relay where you shuttle output between chats by hand. And since osFoundry keeps chat, agents, apps, code, knowledge, and data in one workspace, a handoff can carry references to all of them forward, so the next agent sees not just the last message but the artifacts the pipeline has been building.
Key capabilities
- Pass work from one agent to the next with the full shared context — conversation, intermediate results, and produced files travel with the handoff
- Receiving agents start warm: no re-pasting the brief, no re-explaining the goal, no state lost between steps
- Each agent in the chain can run on a different model — local, cloud, or self-hosted — while sharing the same context
- Context can stay on your device thanks to local-first design, instead of being routed through an external orchestrator
- Runs on your own API keys with no reseller markup and no per-seat fees, so multi-agent chains don't multiply cost per person
Use cases
- Researcher: a gathering agent collects sources and notes, then hands off to a drafting agent that already has every finding in context
- Developer: a planning agent scopes the change and passes the plan, file references, and constraints straight to an implementation agent
- Analyst: a data-prep agent cleans and summarizes, then hands the results to a reasoning agent for interpretation without re-uploading anything
Frequently asked questions
What exactly gets passed during a handoff?
The shared context the chain has built up — the running conversation, the intermediate results, and the files and decisions the previous agent produced. The next agent inherits that instead of a blank slate, so it works from what already happened rather than a fresh prompt.
Can different agents in a handoff chain use different models?
Yes. osFoundry is bring-your-own-key and model-agnostic, so each agent can run on a local, cloud, or self-hosted model. The handoff carries the same shared context between them regardless of which model each agent uses.
Does my data leave my machine when agents hand off to each other?
osFoundry is local-first, so the shared context can stay on your device. Whether a given step touches an external service depends on which model that agent uses — a local model keeps that step on-device, while a cloud model sends what that step needs to your chosen provider under your own key.