Team Sync

Every engineer’s AI agent builds a personal knowledge graph through daily work. Team sync connects these individual graphs into a shared hive mind — an AI-consolidated team knowledge base that grows smarter with every session.

The Flow

flowchart TD
    subgraph "Personal Graphs"
        A1[Alice's AI agent] --> G1[Alice's\nknowledge graph]
        A2[Bob's AI agent] --> G2[Bob's\nknowledge graph]
        A3[Carol's AI agent] --> G3[Carol's\nknowledge graph]
    end

    G1 -->|exposed projects| C1[Alice's\ncontribution DB]
    G2 -->|exposed projects| C2[Bob's\ncontribution DB]
    G3 -->|exposed projects| C3[Carol's\ncontribution DB]

    subgraph "Team Layer"
        C1 --> AG[Consolidation\nagent]
        C2 --> AG
        C3 --> AG
        AG --> TG[Team hive mind]
    end

    subgraph "Recall"
        Q[recall query] --> P[Personal graph]
        Q --> TG
        P --> MR[Merged results\nwith attribution]
        TG --> MR
    end

1. Personal Graphs

Each team member uses Engram normally. Their AI agent stores memories — architecture decisions, debugging insights, code patterns, project conventions — into their personal knowledge graph. Nothing changes about the individual experience.

2. Project Exposure

Team members choose which projects to expose to the team. This is per-project, not all-or-nothing:

• Exposed projects — memories in these projects sync to your contribution database, which teammates can see
• Unexposed projects — stay entirely local, invisible to the team
• Private memories — even within exposed projects, any memory marked is_private stays in your personal graph only

This gives fine-grained control. You might expose “mobile-app” to the Mobile team while keeping “personal-notes” entirely local.

3. Contribution Databases

When a project is exposed, its memories flow to a contribution database — a per-member, per-team database that represents what you’ve shared. Each team member has their own contribution DB, and all are visible to the team.

This is not a copy — it’s a filtered sync. The contribution DB receives memories that pass the exposure filter, encrypted in transit and at rest.

4. AI Consolidation

This is where the hive mind emerges. An AI consolidation agent periodically processes all team members’ contribution databases and synthesizes them into a team graph:

Deduplication — when Alice and Bob both store “use guard let for early returns in Swift,” the agent consolidates them into a single team memory rather than keeping duplicates.

Contradiction detection — when Alice’s memory says “use Redux for state” and Bob’s says “use Context API,” the agent doesn’t pick a winner. It creates a contradicts edge and flags it for team review.

Supersession — when Carol stores an updated architecture decision that supersedes Bob’s older version, the agent creates a supersedes edge. The team graph reflects the latest thinking.

Cross-domain synthesis — the agent surfaces insights that span team members’ domains. Alice’s frontend debugging insight might connect to Bob’s API design decision in ways neither noticed individually.

The consolidated team graph is higher signal and lower noise than the raw contribution databases — it’s not a dump of everyone’s notes, it’s an AI-synthesized knowledge base.

5. Merged Recall

When any team member runs a recall, the system queries across multiple databases:

1. Personal graph — always queried (your own memories)
2. Team graph — queried when the recall’s project maps to a team
3. Raw contributions — also queried, because a teammate might have relevant notes the consolidation agent hasn’t processed yet

Results are merged by relevance score across all sources. The consolidated team graph tends to rank highest (it’s been synthesized for quality), but raw contributions still surface when they’re the best match.

Privacy Model

Privacy is enforced at multiple levels:

Level	Control	Effect
Memory	is_private: true	Never leaves your personal graph, regardless of project exposure
Project	Exposure settings	Per-project, per-team control over what syncs
Team	Membership	Only team members see the team graph

Private memories are excluded from team sync at the source — they never reach the contribution database, never reach the server, never reach the consolidation agent.

Hierarchy

The same pattern scales beyond teams:

flowchart BT
    I1[Individual] --> T1[Mobile Team]
    I2[Individual] --> T1
    I3[Individual] --> T2[Platform Team]
    I4[Individual] --> T2
    T1 --> O[Organization]
    T2 --> O

Each level filters and synthesizes: individual memories (raw) flow into team graphs (synthesized), which can flow into organization graphs (cross-team synthesized). The org graph is a consolidation of team graphs, not of every individual memory — keeping volume manageable and signal high.

Sync Infrastructure

Team sync runs through the Engram server — a Vapor backend that handles:

• Authentication — user accounts and API tokens
• WebSocket relay — real-time bidirectional sync between clients
• Per-user storage — each user’s contribution databases stored server-side
• Subscription management — team features require an active subscription

The server never runs recall or search — all intelligence stays on-device. The server is a sync relay and storage layer, not a compute layer.