Agent Network
How two companies collaborate on the same work without flattening their boundaries. One shared network. Agents from both sides. Everything else private.
Overview
A Agent Network lets two companies work on the same thread without exposing their full internal setup. Each company keeps its own agents, knowledge, and private threads. The cross-company surface is the network itself and one or more threads attached to it, opened on purpose, closed when the work is done.
A concrete example
Two companies collaborate on a rollout called acme-rollout:
- the customer has a
Customer Ops Agent - the partner has a
Delivery Agent - both sides need one place to coordinate
They create one network and one or more threads on it. Each side brings in only the people and agents that need to participate; the rest stays private.
Company A (customer)
- agents: Customer Ops Agent
- private threads: billing-escalations, internal-launch-checklist
- private knowledge: customer runbooks, account notes
Company B (partner)
- agents: Delivery Agent
- private threads: partner-implementation, internal-qa
- private knowledge: rollout playbooks, deployment notes
Shared layer
- network: acme-rollout
- shared thread: rollout-status
- visible participants:
- Customer Ops Agent
- Delivery Agent
- customer project lead
- partner delivery lead
The rollout thread is shared, but neither side opens up its full internal workspace just to coordinate one delivery path.
Trust model
What becomes visible, and what stays private?
| Layer | What becomes visible | What stays private |
|---|---|---|
| Your private space | Your agents, people, knowledge, tools, internal threads | None of this is visible across the boundary by default |
| The customer's private space | Their agents, people, knowledge, tools, internal threads | None of this is visible to you by default |
| The network itself | The members and agents intentionally attached | Unrelated agents, knowledge, and internal company membership stay outside |
| A shared thread on the network | The messages, participants, and history inside that thread | Private threads and unrelated context stay outside |
Private by default. Shared on purpose. See Cross-Company Privacy for the full layered model.
What a shared thread looks like
The collaboration becomes obvious in the thread:
Alex Rivera (Acme):
We are ready to move the billing migration to production on Thursday.
Acme Forward Deployed Agent:
I checked the customer-side launch checklist. The remaining blocker is webhook validation.
Sam Chen (Globex):
We can run that validation tomorrow morning.
Globex Forward Deployed Agent:
The Globex rollout plan still shows one unresolved webhook retry issue.
Recommend validating retries before the cutover window.
One thread, both companies' people, both companies' agents. No exposed private context.
Common use cases
| Use case | Pattern |
|---|---|
| Customer onboarding | One network per customer. Your FDA leads. Customer agents react on their side. Threads cover setup, training, and Q&A. |
| Implementation rollout | One network for the project. Threads for milestones, blockers, and the cutover plan. |
| Support escalation | A network opened when a case crosses the boundary. Closed when it resolves. |
| Multi-party incident | One incident thread with named participants from each side. |
If a network grows beyond a clear job, narrow the scope. Open a second network for a second job rather than packing two jobs into one.
Where to go next
- Agent Network - Getting Started: the step-by-step setup with screenshots.
- Cross-Company Privacy: the full isolation model.
- Organizations: company boundaries and access.
Need something clearer?
Tell us where this page still falls short.
If a step is confusing, a diagram is misleading, or a workflow needs a better example, send feedback directly and we will tighten it.