Team-Scoped Memory

Durable memory owned by the current project's team. Authorized agents can store or recall shared decisions and learnings without turning a memory scope into a coordination group.

Overview

Team Memory extends Agent Memory to work across multiple agents and human teammates. This enables:

• Knowledge sharing — Reviewed discoveries can be recalled across the team
• Reviewable lifecycle — Shared candidates retain owner and authority data
• Cross-project continuity — Team-owned knowledge can be reused by authorized projects
• Explicit filtering — Callers can request only the team partition

How It Works

// Agent A discovers a pattern

snipara_remember({

  text: "The payment API requires idempotency keys",

  type: "fact",

  scope: "team",  // Share with the team

  category: "backend"

})

// Agent B (different session) can recall it

snipara_recall({

  query: "What do I need for payment API calls?",

  scope: "team"

})

// Returns: "The payment API requires idempotency keys"

Memory Scopes

Memories can exist at different scopes:

Team Memory vs Swarms

A team is an account/workspace boundary managed through Snipara membership and access controls. Setting scope: "team" stores memory against that existing team. It does not create a new team, group, membership list, or swarm.

snipara_swarm_create belongs to multi-agent coordination. A swarm has agents, tasks, events, and plan-limited capacity, but it does not define a memory scope. Use multi-agent coordination when you need task orchestration rather than durable team-owned knowledge.

MCP Tools for Team Memory

Storing Group Memories

Use the scope parameter to control visibility:

snipara_remember({

  text: "Use snake_case for database column names",

  type: "decision",

  scope: "team",

  category: "coding-standards"

})

Recalling Group Memories

When recalling, specify the team scope to include shared memories:

snipara_recall({

  query: "What are our database naming conventions?",

  scope: "team",

  category: "coding-standards"

})

Listing Team Memories

Use snipara_memories with scope filtering to browse team memories:

snipara_memories({

  scope: "team",

  category: "coding-standards",

  limit: 20

})

Recall Across Scopes

Pass scope: "team" to query only the team-owned partition. If scope is omitted, recall may gather the authorized agent, user, team, and project partitions before ranking all candidates by semantic relevance, confidence, lifecycle authority, and bounded intent-specific signals. There is no fixed agent → team → project priority order.

Response fields such as scope_partitions, owner,authority_status, and ranking_boosts explain which partitions and bounded signals affected a particular result.

Use Cases

Team Coding Standards

Store coding conventions as team rules so all agents follow the same patterns:

snipara_remember({

  text: "All API responses must include a 'success' boolean field",

  type: "decision",

  scope: "team",

  category: "api-standards"

})

Shared Discoveries

When one agent discovers something useful, share it as a reviewed candidate first. Project policy decides whether it can be approved with a receipt or must wait in the review inbox before another agent recalls it.

// Agent finds a bug workaround

snipara_remember({

  text: "The stripe SDK has a bug with null metadata - always pass empty object",

  type: "learning",

  category: "bugs",

  scope: "team"

})

Project Context

Store project-wide facts that all agents should know:

snipara_remember({

  text: "This project uses Next.js 14 with App Router",

  type: "fact",

  scope: "project"  // Available to all project agents

})

Best Practices

• Use team scope for shared knowledge— Don't over-share personal preferences
• Use categories for organization — Group related memories with meaningful category names
• Keep scopes focused— Use "project" for project-specific, "team" for cross-project knowledge
• Review team memories periodically — Prune outdated information
• Combine with Snipara Context — Use memories for dynamic knowledge, Context for static docs

Platform Capacity

Memory and swarm capacity are separate limits. Team-scoped memory counts against the platform memory allowance; creating a swarm counts against the swarm allowance.

Next Steps