Solution · Multi-Agent

Let your agents work as a team.

A research agent finds the sources. An analysis agent compares them. A review agent needs both the conclusion and the evidence behind it. Minds helps you organize each agent’s context, share selected knowledge, and find the capabilities the next task requires.

The right capability for the task
Illustrated workflow

Capability dispatch

A task finds the right capabilities.

Example request / 017
Route request

Find context for a review

Identify a graph path and related source material for the current task.

Required capabilities
  • 01graph_traversal
  • 02vector_search
Organizationdesk
A

Alpha

Graph specialist
Agent namespace alpha
Registered capabilitygraph_traversalMatched to requirement 01
Visibility
org_internal
Dataspace
desk
Host
alpha.local
B

Beta

Search specialist
Agent namespace beta
Registered capabilityvector_searchMatched to requirement 02
Visibility
org_internal
Dataspace
desk
Host
beta.local
Returned route plan

Two matches. Two route steps.

02 steps
  1. 01
    Alphagraph_traversal
    alpha.local/v1/query
  2. 02
    Betavector_search
    beta.local/v1/query

The router returns a plan. Your application dispatches the work and enforces access policies.

How a task finds an agent

Match the next task to the right capability.

Register what each agent can do, then ask the Knowledge Router to find matching agents for your plan. For a research review, that could mean one agent to follow citation links and another to search the source material. Your application uses the returned route to coordinate the work.

01

Context

Give each agent a place to work.

Use an agent-scoped namespace to organize its records and requests. Configure authorization separately to control access to those records.

02

Capabilities

Make each agent’s skills discoverable.

Register the tasks an agent can handle, along with its identity and endpoint, so the router can find it.

03

Knowledge

Connect the facts the team shares.

Write useful relationships to a graph that authorized agents can query, while keeping agent-specific context separately scoped.

04

Routing

Turn requirements into a route.

Describe the capabilities a task needs. The router returns matching agent endpoints for your application to call.

Clear boundaries

Coordinate the work. Keep ownership clear.

A routing plan identifies where a task can go. Agents still manage their own execution, and your access policies determine which knowledge they can use or share.

01

Visibility

Choose how a capability is listed.

A capability record can carry a public, organization-internal, or private visibility label. Enforce the corresponding access rules in your deployment.

02

Identity

Check who is registering.

Registration includes an identity proof that the router’s configured trust adapter validates.

03

Execution

Keep the handoff explicit.

Inspect the returned route and dispatch the task through your application. A route identifies a destination; executing and completing the work remain part of your workflow.

04

Memory

Share the useful result.

Keep an agent’s events and procedures in its own scope, then publish selected knowledge through the shared graph according to your access policies.

Developer integration

Two agents. One plan.

This application excerpt registers two agents and requests a route for their capabilities. It assumes a configured KnowledgeRouter gRPC adapter with secure transport and identity proofs accepted by your trust policy. Memory storage and task execution are separate integrations.

Application excerpt · registerCapability · routeTasktypescript
// router is your configured KnowledgeRouter gRPC adapter.
// Its methods below wrap the corresponding RPCs as promises.
const alphaToken = process.env.ALPHA_ROUTER_IDENTITY_TOKEN;
const betaToken = process.env.BETA_ROUTER_IDENTITY_TOKEN;
if (!alphaToken || !betaToken) throw new Error("Configure agent identity proofs");

await router.registerCapability({
  descriptor: {
    agentId: "alpha",
    dataspaceId: "desk",
    host: "alpha.local",
    queryEndpoint: "/v1/query",
    capabilities: ["graph_traversal"],
    visibility: "org_internal",
    identityProof: { scheme: "jwt", payload: Buffer.from(alphaToken, "utf8") },
  },
});

await router.registerCapability({
  descriptor: {
    agentId: "beta",
    dataspaceId: "desk",
    host: "beta.local",
    queryEndpoint: "/v1/query",
    capabilities: ["vector_search"],
    visibility: "org_internal",
    identityProof: { scheme: "jwt", payload: Buffer.from(betaToken, "utf8") },
  },
});

const plan = await router.routeTask({
  plan: {
    requirements: [
      { capability: "graph_traversal" },
      { capability: "vector_search" },
    ],
  },
});
// Inspect plan.steps, then dispatch through your application.
Developer reference

The information behind a routing plan.

A registered capability includes the agent’s identity, visibility, and endpoint. A returned plan identifies the steps your application can dispatch.

KnowledgeRouter
RPCs
RegisterCapability · QueryCapabilities · RouteTask
Visibility
public · org_internal · private
Required on register
descriptor · identityProof · dataspaceId
Route plan
TaskRoutePlan.steps (dataspace, host, endpoint, capability)
Application responsibilities
Connection
Configured gRPC adapter and secure transport
Memory
Authorized access to stored records and shared knowledge
Dispatch
Call returned endpoints and record task outcomes
Access
Enforce the policies behind capability visibility

Build a team that can use what it knows.

Start with two agents, define what each can do, and connect the knowledge they need for a shared task.