For Teams

One memory. Many agents. Shared intelligence.

Every agent on your team learns from every other. Namespaces, RBAC, pub/sub — so knowledge compounds instead of siloing.

Architecture

Four agents. One shared graph. Scoped permissions.

Each agent reads and writes to a central memory. Namespaces and RBAC decide what each agent can see, write, or consolidate.

Agents with scoped API keys Central memory graph RBAC scopes per namespace

Team Patterns

Three teams. One pattern.

Every team we've onboarded ends up with a variant of the same shape: many specialized agents, one shared memory, scoped permissions.

Customer Success

Customer success swarm

Support, success, and billing agents all see the same customer context. A refund handled in billing is visible in the next support ticket automatically.

support-bot · reads + writes cx/*

success-bot · reads cx/*, writes cx/notes

billing-bot · reads cx/*, writes billing/*

Research Cluster

Research agent cluster

Literature, synthesis, and critique agents share findings on a pub/sub channel. One agent's discovery becomes another's citation in seconds, not weeks.

literature-agent · writes findings/*

synthesis-agent · reads findings/*, writes summaries/*

critique-agent · reads summaries/*, writes critiques/*

Dev Team

Internal dev team copilots

Five developers, five personal copilots, one shared project memory. Architectural decisions, debugging sessions, and code review context all compound.

5 × dev-copilot · reads + writes project/*

pr-reviewer-bot · reads project/*, writes reviews/*

incident-bot · reads project/*, writes incidents/*

Capabilities

Everything a team needs.

Built into the memory primitive from day one, not bolted on later.

Namespaces

Scope memory per team, project, agent, or tenant. Unlimited namespaces. No context bleed.

RBAC per namespace

Read, write, consolidate, and delete permissions scoped to every namespace and every agent.

Pub/sub channels

Agents broadcast and subscribe to topics. Real-time propagation via WebSocket and webhooks.

Shared dream cycles

Dream Engine runs once across the whole team. Consolidation cost is shared, not duplicated.

Agent-scoped API keys

One key per agent. Rotate, revoke, and audit independently. Per-key rate limits.

Federation audit log

Every cross-agent read, write, and consolidation is logged. Exportable and searchable.

Teams Plan

$99 / month per 10 agents. Dream Engine cycles shared across the team. Unlimited namespaces. Audit log included. No per-seat user pricing.

See full pricing →

Quick Start

Set up a team workspace in 3 minutes.

Three API calls: create a namespace, add agents, scope permissions. Everything else is automatic.

Create a namespace for your team.

Namespaces are free, unlimited, and fully isolated from each other.

# Create team namespace
curl -X POST https://api.remlabs.ai/v1/namespaces \
  -H "Authorization: Bearer $REM_KEY" \
  -d '{"name":"acme-support","description":"Customer success swarm"}'

Add agents with scoped keys.

Each agent gets its own API key. Rotate and revoke independently.

# Add agents (one key per agent)
curl -X POST https://api.remlabs.ai/v1/agents \
  -H "Authorization: Bearer $REM_KEY" \
  -d '{"namespace":"acme-support","name":"support-bot"}'

curl -X POST https://api.remlabs.ai/v1/agents \
  -H "Authorization: Bearer $REM_KEY" \
  -d '{"namespace":"acme-support","name":"billing-bot"}'

Scope permissions per agent.

Assign read, write, consolidate, and delete scopes. RBAC is enforced at the memory primitive.

# Scope billing-bot to read cx, write billing
curl -X POST https://api.remlabs.ai/v1/agents/billing-bot/scopes \
  -H "Authorization: Bearer $REM_KEY" \
  -d '{"read":["cx/*"],"write":["billing/*"],"consolidate":["billing/*"]}'

Stop siloing your team's intelligence.

Start a team trial today. No credit card. Migrate from single-agent whenever you are ready.

Start team trial → See enterprise features →