Overview

Welcome to TeamLoop

TeamLoop is a temporal intelligence platform that transforms how you interact with enterprise knowledge. Unlike traditional RAG (Retrieval-Augmented Generation) systems that only show current state, TeamLoop tracks how knowledge evolves over time.

The Problem with Traditional RAG

When you ask a traditional AI assistant about your codebase or documentation:

• You get today’s answer, not the full context
• You lose the “why” behind decisions
• You can’t understand what was known when past decisions were made
• Historical context is lost forever

TeamLoop’s Solution: Temporal Intelligence

TeamLoop introduces time-aware knowledge retrieval:

Feature	Traditional RAG	TeamLoop
Query Mode	Current state only	Current, as_of, evolution, compare
Search	Vector-only	Hybrid (vector + full-text + RRF fusion + cross-encoder reranking), optimized with batch queries and parallel execution
Decision Context	Lost over time	Preserved with lineage
Knowledge Structure	Flat documents	Connected knowledge graph
Source Attribution	Often missing	Always tracked
Version Tracking	Manual snapshots	Automatic temporal versioning

Core Concepts

Knowledge Graph

TeamLoop extracts and connects entities from your tools:

• Decisions - Architectural choices, policy changes, design decisions
• Documents - PRDs, ADRs, specs, meeting notes
• Changes - Commits, field updates, status changes
• People - Authors, reviewers, decision makers
• Components - Systems, services, modules
• Projects - Initiatives, features, workstreams
• Facts - Atomic, independently searchable facts extracted from documents and decisions

Learn more: Knowledge Graphs

Temporal Versioning

Every piece of knowledge has temporal metadata:

• event_date - When the event actually occurred
• valid_from / valid_to - When this version of knowledge was current
• supersession - What this decision replaced and what replaced it

Query-First Architecture

TeamLoop doesn’t sync your data in the background. Instead:

1. You make a query
2. TeamLoop fetches fresh data from integrations
3. Results are cached with embeddings for future use
4. Knowledge graph grows organically from actual queries

Core Features

Retrieval

• Hybrid Search - Multi-stage pipeline combining vector search, BM25 full-text search, RRF fusion, and cross-encoder reranking for high-precision retrieval.
• Agentic Retrieval - LLM-driven sufficiency loop that detects incomplete results and issues reformulated queries to fill knowledge gaps.
• Context Reconstruction - Supplementary signal layer that augments results with active foresight predictions, unresolved conflicts, temporal span, and an optional LLM-generated context summary.
• Fact Extraction - Decomposes large documents and decisions into atomic, independently searchable facts for precise retrieval.

Intelligence

• Foresight - Auto-generates forward-looking predictions from decisions, tracking downstream implications and detecting when predictions come true.
• Journal - Captures thoughts, decisions, and context as structured entries that integrate into the knowledge graph with auto-linking.
• Agent Memory - Gives AI assistants persistent, temporal memory across conversations with natural-language remember, recall, and context tools.

Organization

• Subgraphs - Curated collections of entities for specific projects, topics, or synthesis tasks.
• Auto-Clustering - Automatic entity grouping that detects natural clusters in your knowledge graph and suggests them as subgraph starting points.
• Synthesis - Generates structured documents (ADRs, PRDs, executive briefs) from curated subgraphs using AI.

Exploration

• Query Playground - Temporal query modes: current state, point-in-time (as_of), evolution over a range, and side-by-side comparison of two dates.

Supported Integrations

TeamLoop connects to:

• GitHub - Issues, PRs, discussions, commits
• Jira - Issues, epics, sprints, changelogs
• Confluence - Pages, spaces, version history
• Notion - Pages, databases, comments
• Linear - Issues, projects, roadmaps
• Asana - Tasks, subtasks, project activity
• Figma - Design files, versions, comments
• Zendesk - Tickets, comments, audit history
• Datadog - Monitors, events, state changes
• PagerDuty - Incidents, timelines, escalations

How It Works

┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│   Claude    │◄──►│  TeamLoop   │◄──►│  Your Tools │
│  (via MCP)  │    │   Server    │    │ GitHub/Jira │
│             │    │             │    │ Notion/etc  │
└─────────────┘    └──────┬──────┘    └─────────────┘
                         │
                         ▼
                  ┌─────────────┐
                  │  Knowledge  │
                  │    Graph    │
                  │ (PostgreSQL)│
                  └─────────────┘

1. Query: You ask Claude about your project
2. Fetch: TeamLoop queries your connected tools
3. Extract: Claude extracts entities and relationships
4. Store: Knowledge is versioned in the graph
5. Learn: Future queries benefit from accumulated knowledge

Example: Following a Decision Over Time

Here’s how TeamLoop works in practice across a two-week span.

Day 1 — Record a decision

You’re in a conversation with Claude and mention an architecture decision:

You: "We decided to migrate the public API from REST to gRPC. The main
     drivers are performance for mobile clients and strong typing with
     protobuf. We evaluated GraphQL but chose gRPC for backend-to-backend
     communication."

Claude: [uses teamloop_remember]
→ Saved DECISION: "Migrate public API from REST to gRPC"
  Saved COMPONENT: "Public API"
  Created relationship: DECISION → RELATES_TO → COMPONENT
  Conflict detection: no conflicts found.

Behind the scenes, Foresight generates predictions:

• “SDK client libraries will need regeneration for gRPC/protobuf” (85%, 6 weeks)
• “API gateway may need gRPC-compatible replacement” (70%, 4 weeks)

Day 5 — Ask about the project

You: "What's the current state of the API migration?"

Claude: [uses teamloop_query]
→ Found 4 entities (hybrid search + agentic retrieval)
  Context: 1 active prediction about SDK regeneration,
  no unresolved conflicts, results span 5 days.

Agentic Retrieval detects that initial results only cover the gRPC decision and issues a reformulated query to find related API gateway discussions. Context Reconstruction surfaces the active foresight prediction about SDK impacts.

Day 10 — A conflicting decision appears

A teammate records a different decision in a Notion doc:

You: "What do we know about API design?"

Claude: [uses teamloop_query]
→ Found 6 entities.
  Context: ⚠️ Unresolved conflict detected —
  "Migrate API to gRPC" conflicts with "Use GraphQL for frontend APIs"
  (similarity: 0.87). 1 active prediction. Results span 10 days.

TeamLoop automatically detected the conflict between the two API decisions and surfaced it via context reconstruction.

Day 14 — Review how things evolved

You: "How has our API architecture thinking evolved this month?"

Claude: [uses teamloop_evolution]
→ 3 periods:
  Week 1: Decided on gRPC migration
  Week 2: GraphQL proposal for frontend APIs (conflict detected)
  Week 2: Selected Envoy as API gateway (auto-fulfilled prediction)

The gRPC gateway prediction auto-fulfilled when the Envoy decision was saved (semantic similarity: 0.89). The Query Playground in the dashboard lets you visualize this timeline with the knowledge graph.

Next Steps

Ready to get started?

1. Quick Start Guide - Set up TeamLoop in minutes
2. MCP Setup - Configure your AI assistant
3. Query Playground - Learn temporal query modes