# How to Implement Multi-Agent Shared Context and Team Memory in Semantica

> Implement multi-agent shared context and team memory in Semantica. Instantiate AgnoSharedContext, bind agents, and use toolkits for seamless knowledge sharing and decision-making.

- Repository: [Semantica /semantica](https://github.com/semantica-agi/semantica)
- Tags: how-to-guide
- Published: 2026-08-16

---

**Instantiate `AgnoSharedContext` to create a single source of truth, bind each agent with `bind_agent(role)` to get role-scoped memory stores, and use built-in toolkits like `AgnoDecisionKit` to let agents read and write team-wide knowledge.**

Multi-agent systems fail when agents work in isolation. Semantica solves this through a **team-wide memory layer** that lets Agno agents share context while maintaining private namespaces. This article walks through the architecture and implementation based on the actual source code in `semantica-agi/semantica`.

## Architecture of Semantica's Shared Context System

The multi-agent shared context system centers on three components: a unified storage backend, role-scoped access controls, and thread-safe concurrent operations.

### Single Source of Truth with `AgnoSharedContext`

In [`integrations/agno/shared_context.py`](https://github.com/semantica-agi/semantica/blob/main/integrations/agno/shared_context.py), the `AgnoSharedContext` class creates one `AgentContext` and `ContextGraph` instance for the entire team. All agents read from and write to the same vector store and knowledge graph.

```python
from semantica.vector_store import VectorStore
from semantica.context import ContextGraph
from integrations.agno import AgnoSharedContext

vector_store = VectorStore(backend="faiss")
knowledge_graph = ContextGraph(advanced_analytics=True)

shared = AgnoSharedContext(
    vector_store=vector_store,
    knowledge_graph=knowledge_graph,
    decision_tracking=True,
    graph_expansion=True,
)

```

This design eliminates data silos. Every memory, decision, and insight persists in shared infrastructure.

### Role-Scoped Memory Views

The `bind_agent(role)` method returns an `_AgentScopedStore` that subclasses `AgnoContextStore`. This store forwards all operations to the shared context but tags every entry with the agent's role using `session_id = f"{team_session}::{role}"`.

This architecture delivers two benefits:

- **Isolation**: Each agent has a private namespace for its own memories
- **Transparency**: All agents can read the global memory pool through `read_memories`

The scoped store merges its private cache with the shared pool during reads, then applies optional filtering and sorting.

### Thread-Safe Concurrent Operations

A re-entrant lock protects binding and decision-recording:

```python
self._lock = threading.RLock()

```

This allows agents to run concurrently without race conditions when accessing shared memory.

## Core Capabilities for Team Memory

### Automatic Decision Tracking

When `decision_tracking=True`, every `upsert_memory` call automatically inserts a lightweight decision entry with `category="memory:<role>"`. The global `record_decision` API also adds a role tag (`category:agent_role`).

This creates an audit trail connecting every memory to its originating agent.

### Graph-Expanded Context Retrieval

With `graph_expansion=True`, the base `AgnoContextStore.read_memories()` can enrich results with one-hop neighbors from the knowledge graph. Agents receive context-aware recall that surfaces related concepts even when not explicitly queried.

### Team-Level Query APIs

`AgnoSharedContext` exposes three public methods for orchestration:

- `find_precedents(scenario, limit)` — Searches for similar past decisions
- `get_shared_insights()` — Returns analytics across all team contributions
- `knowledge_graph` — Direct access to the full decision graph

## Complete Implementation Example

### Step 1: Create Shared Infrastructure

```python
from semantica.vector_store import VectorStore
from semantica.context import ContextGraph
from integrations.agno import AgnoSharedContext, AgnoDecisionKit, AgnoKGToolkit

vector_store = VectorStore(backend="faiss")
knowledge_graph = ContextGraph(advanced_analytics=True)

shared = AgnoSharedContext(
    vector_store=vector_store,
    knowledge_graph=knowledge_graph,
    decision_tracking=True,
    graph_expansion=True,
)

```

### Step 2: Bind Agents to Shared Context

```python
from agno.agent import Agent
from agno.team import Team

researcher_mem = shared.bind_agent("researcher")
analyst_mem = shared.bind_agent("analyst")

researcher = Agent(
    name="Researcher",
    memory=researcher_mem,
    tools=[AgnoKGToolkit(context=shared)],
)

analyst = Agent(
    name="Analyst",
    memory=analyst_mem,
    tools=[AgnoDecisionKit(context=shared)],
)

team = Team(agents=[researcher, analyst], mode="coordinate")

```

### Step 3: Store and Retrieve Shared Knowledge

```python

# Researcher contributes knowledge

researcher.memory.upsert_memory(
    {"memory": "Quantum computing reduces cryptographic safety.", "user_id": "u1"}
)

# Analyst accesses combined knowledge pool

all_memories = analyst.memory.read_memories()
print([m["memory"] for m in all_memories])

```

### Step 4: Record Structured Decisions

```python
researcher.memory.record_decision(
    category="strategy",
    scenario="Should we invest in post-quantum crypto?",
    reasoning="Market analysis + technical risk assessment",
    outcome="invest",
    confidence=0.93,
    entities=["Quantum computing", "cryptography"]
)

```

### Step 5: Inject Shared Context into Prompts

```python

# General team insights

prompt_prefix = shared.get_shared_insights()

# Specific scenario search

context_snippet = shared.find_precedents(
    scenario="Secure communications after quantum breakthrough",
    limit=3,
)

```

## Source File Reference

| File | Purpose |
|------|---------|
| [`integrations/agno/shared_context.py`](https://github.com/semantica-agi/semantica/blob/main/integrations/agno/shared_context.py) | `AgnoSharedContext` — team coordinator and binding logic |
| [`integrations/agno/context_store.py`](https://github.com/semantica-agi/semantica/blob/main/integrations/agno/context_store.py) | `AgnoContextStore` and `_AgentScopedStore` — storage implementation |
| [`integrations/agno/decision_kit.py`](https://github.com/semantica-agi/semantica/blob/main/integrations/agno/decision_kit.py) | `AgnoDecisionKit` — decision intelligence tools |
| [`integrations/agno/kg_toolkit.py`](https://github.com/semantica-agi/semantica/blob/main/integrations/agno/kg_toolkit.py) | `AgnoKGToolkit` — knowledge graph search tools |
| [`semantica/context.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/context.py) | Core `AgentContext` and `ContextGraph` classes |
| [`semantica/vector_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store.py) | Vector storage backends (FAISS, Qdrant, etc.) |

## Summary

- **`AgnoSharedContext`** creates a single vector store and knowledge graph for the entire team
- **`bind_agent(role)`** returns scoped stores that isolate private memories while allowing global read-through
- **Thread-safe design** with `RLock` enables concurrent agent execution
- **Automatic decision tracking** links every memory to its source agent for auditability
- **Graph expansion** enriches retrievals with related concepts from the knowledge graph
- **Built-in toolkits** (`AgnoDecisionKit`, `AgnoKGToolkit`) expose team memory as Agno tools

## Frequently Asked Questions

### How does Semantica prevent agents from overwriting each other's memories?

Role-scoped stores use composite session IDs (`f"{team_session}::{role}"`) to tag every entry. While all agents read from the shared pool, writes are tagged with the originating role. The `_AgentScopedStore` class in [`integrations/agno/shared_context.py`](https://github.com/semantica-agi/semantica/blob/main/integrations/agno/shared_context.py) handles this transparently without requiring changes to agent code.

### Can I use a different vector store backend with AgnoSharedContext?

Yes. The `VectorStore` class in [`semantica/vector_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store.py) abstracts the backend. Pass any supported backend—`"faiss"`, `"qdrant"`, or others—to `VectorStore()` before injecting it into `AgnoSharedContext`. The rest of the multi-agent shared context system remains unchanged.

### What happens when two agents call `read_memories()` simultaneously?

The re-entrant lock (`self._lock = threading.RLock()`) in `AgnoSharedContext` protects critical sections. Multiple agents can read concurrently since reads don't conflict. The lock ensures atomic binding operations and prevents interleaving during decision recording, maintaining consistency of the team memory state.

### How do I query decisions made by a specific agent role?

Use `find_precedents()` with filters, or access the knowledge graph directly through `shared.knowledge_graph`. Decision entries are tagged with `category:agent_role`, allowing targeted queries. The `AgnoDecisionKit` also provides `search_decisions()` which accepts role filters as parameters.