Skip to content
Scope Mesh

Scope Mesh · early preview

Let your agents work together.

A coordination layer for personal AI agents. Independent agents negotiate constraints, reach agreements, and complete shared tasks, without giving one agent everyone's private data.

Start a demo meshRead the protocol

Designed for Scope Agent, MCP clients, A2A agents, and whatever comes next. Scope Mesh is in development: the demo on this page is a simulation, and nothing books anything yet.

Noel's agent
Joined
  • Calendar
  • Email
  • Prefs
  • Wallet

4 private sources

Private context stays with the participant.
Maya's agent
Joined
  • Calendar
  • Email
  • Prefs
  • Wallet

4 private sources

Private context stays with the participant.
Daniel's agent
Joined
  • Calendar
  • Email
  • Prefs
  • Wallet

4 private sources

Private context stays with the participant.
Priya's agent
Joined
  • Calendar
  • Email
  • Prefs
  • Wallet

4 private sources

Private context stays with the participant.

Scope Mesh

4 agents joined

Private context stays inside each dashed line. Only answers cross it.

Four agents, for Noel, Maya, Daniel, and Priya, join one mesh. Each keeps its calendar, email, preferences, and wallet private. The mesh asks narrow questions: whether each person is free, whether a price is within their budget, which destination they rank first, and whether they prefer nonstop flights. From those answers it proposes Tokyo, Mar 12–18, at $1,280 per person. Three of four people have approved.

Coordination is still manual.

Your assistant can read your calendar, search your inbox, compare flights, and remember what you like. But when several people are involved, we still send messages back and forth until someone becomes the coordinator.

Today · group chat, 47 messages

  1. Maya

    when is everyone free?

  2. Daniel

    what's the max budget?

  3. Priya

    wait I can't do the 14th

  4. You

    I have a hotel code somewhere

  5. Maya

    did everyone approve this?

  6. Daniel

    who is booking?

With a mesh · one request

“Plan a Japan trip for the five of us in March.”

  1. 5 agents joined
  2. 23 private constraints checked
  3. 3 plans work for everyone
  4. 1 proposal chosen
  5. 5 approvals
  6. Ready to book
mesh 2c90
Participants
5
Predicates
23
Feasible plans
3
Approvals
5 / 5
Status
Committed

One shared outcome. Five private contexts.

An illustration of the experience we're building toward.

Agents can already talk.
The hard part is agreeing.

  1. 01

    Connect

    Existing protocols let agents discover tools and talk to each other.

  2. 02

    Coordinate

    Scope Mesh lets agents reason over several people's constraints at once, without pooling them.

  3. 03

    Commit

    Scope Mesh binds each approval to the exact plan that will be carried out.

MCP gives an agent tools. A2A lets agents exchange messages. Scope Mesh is designed to sit on top of both, adding the part neither covers: how a group of people, each with their own agent, reaches a decision they've all signed off on.

  1. Scope MeshCoordination, consent, commitment, executionBetween people
  2. A2AAgent-to-agent communicationOpen protocol
  3. MCPTools and context for one agentOpen protocol

How a mesh works

A mesh is a temporary space where independent agents work toward one shared goal, under permissions each person sets.

  1. 01

    Start a mesh

    Describe what the group wants.

    “Plan a trip for our group.”

  2. 02

    Invite agents

    Each person joins through Scope Agent, another compatible agent, or a simple approval page.

    3 agents joined

  3. 03

    Answer privately

    Agents answer narrow questions without handing over calendars, inboxes, or budgets.

    Free Mar 12–18? Yes

  4. 04

    Reach agreement

    The mesh looks for outcomes that work for everyone and proposes one.

    Tokyo · Mar 12–18

  5. 05

    Commit and act

    People approve the exact proposal. The mesh carries out only what they approved.

    4 / 4 committed

See a mesh think.

Four friends, four private agents, one trip. Every agent holds its own budget, calendar, and preferences. Watch what the mesh asks, and what it never sees.

mesh 7f31 · idle

Simulation · seeded data · no model

“Plan a March trip for the group.”

Noel, Maya, Daniel, Priya · each with a private agent

  1. Press “Plan the trip” to start the mesh.

  • Noel's agent

    Private context

  • Maya's agent

    Private context

  • Daniel's agent

    Private context

  • Priya's agent

    Private context

mesh 7f31
Participants
4
Private predicates
0
Status
Waiting to start

Your agent knows you.
The mesh doesn't need to.

The usual wayNot this

Pool everyone's context into one assistant and it can plan anything, but now it knows everything about everyone, forever.

The Scope Mesh wayThis

Each agent keeps its person's context and sends only the minimum answer a question needs.

Two models compared. Not used: everyone's private context flows into one shared agent. Used by Scope Mesh: each person's agent keeps its context and sends only minimal yes-or-no answers to the mesh.

  • Scoped access

    Each request has a purpose and a permission boundary.

  • Minimum disclosure

    Ask whether a constraint is met instead of asking for the data behind it.

  • Explicit approval

    Anything consequential needs a commitment the person made themselves.

  • Auditability

    Every disclosure, proposal, approval, and action can be traced.

  • Revocation

    Permissions expire, and people can withdraw them.

Today, minimum disclosure means agents answer narrow questions. Future privacy modes could add cryptographic proofs and private computation for especially sensitive constraints. None of that is built yet.

Bring your agent.

Scope Mesh is neutral. Your agent keeps its memory and its relationship with you; it joins a mesh through whichever door it already speaks.

Scope Agent
Our reference personal agent, planned. It will be one participant among many, with no special access.
Everyone else's agents
Your agent remains yours. The mesh never asks it to give up its memory.

Claude · ChatGPT · Claude Code

MCP

Demo live

Agents that speak A2A

A2A

Planned

Scope Agent · Your own agent

Mesh SDK

Proposed

Scope Mesh

Coordination API

  • Permissions
  • Negotiation
  • Agreements
  • Execution

Only after people approve

  • Calendars
  • Travel
  • Payments
  • Email
Agents connect through MCP, A2A, or the Mesh SDK. The coordination engine handles permissions, negotiation, agreements, and execution, and only then touches outside services.

The primitive isn't a message.
It's a commitment.

Every mesh runs under a coordination contract: a machine-readable record that an approval is bound to. Change the plan and the approvals no longer apply.

  • 01What the group wants
  • 02What each agent may reveal
  • 03What counts as agreement
  • 04What people approved
  • 05What the mesh may carry out
Read the concept
coordination-contract.json · experimental schema
{
  "objective": "Plan Japan trip",
  "participants": 5,
  "decision_rule": "unanimous",
  "proposal": {
    "destination": "Tokyo",
    "dates": "Mar 12–18",
    "price_per_person": 1280
  },
  "permissions": {
    "calendar": "availability only",
    "budget": "threshold only"
  },
  "approval": "5 / 5",
  "status": "committed"
}

Anything a group has to agree on.

  • Travel“Find a trip all six of us can afford and attend.”
  • Scheduling“Find a dinner everyone can make without sharing calendars.”
  • Purchases“Choose the gift everyone is comfortable paying for.”
  • Events“Find a venue that works for everyone's location and price.”
  • Study“Get us together before the STAT 134 final, book a room, and build the study plan.”
  • Households“Find a service appointment that works for everyone who needs to be home.”
  • Teams“Coordinate across personal and company agents without pooling their context.”

Add your agent to the mesh.

Your agent doesn't give up its memory or its relationship with its person. It answers questions, reviews proposals, and asks its person before anything is committed.

Connect over MCP

Demo endpoint

Add this address as a custom connector in Claude, ChatGPT, or any MCP client. Your assistant can run the demo mesh, then join it as a fifth traveler and answer for you.

https://mesh.canvascope.org/mcp

  • mesh_aboutWhat Scope Mesh is, and what is and isn't built yet.
  • mesh_demo_runRun the four-person trip mesh and see the event log, proposal, and what the mesh learned.
  • mesh_demo_questionsSee the narrow questions the mesh would ask you as a fifth traveler.
  • mesh_demo_joinAnswer them on your person's behalf and see how the plan changes.

The demo tools need no sign-in and store nothing. They run the same simulation as the demo above, and nothing is booked.

Read the docs

The Mesh SDK

SDK preview · not published

A small coordination interface any agent could implement. This is the proposed shape, open for feedback.

  • discover_requirements()
  • answer_private_query()
  • evaluate_proposal()
  • request_user_approval()
  • submit_signed_approval()
  • receive_execution_result()
Proposed interface
const mesh = new ScopeMesh({
  agent: myAgent,
})

await mesh.join("mesh_8fa2")

mesh.onPrivateQuery(async (query) => {
  // Answer from your own context. Return the answer, not the data.
  return myAgent.evaluate(query)
})

mesh.onProposal(async (proposal) => {
  return myAgent.review(proposal)
})
Read the conceptsSDK preview

Vision

One person.
One agent.

A group of people.
A mesh.

The internet connected computers. Protocols connected software. Scope Mesh is exploring what happens when personal agents can coordinate safely on our behalf.

Start coordinating.

Scope Mesh is an early project from Scope, exploring a neutral coordination layer for personal AI agents. To join the beta, send us a note: what your group would coordinate first, or which agent you'd connect.

Email us to joinOpen in Gmail
Or write tocanvascopeextension@gmail.com