ContextOS

ContextOS turns AI incident investigations into permanent company memory, extracting verified safeguards from Slack, GitHub, and Jira to prevent repeat outages before code merges.

Comment

Inspiration

ContextOS was inspired by Cerebras' Single Retrieval Layer paradigm: enterprise knowledge naturally lives across operational tools like Slack, GitHub, Jira, and architecture docs—not centralized wikis.

But existing enterprise AI has a critical blind spot: operational amnesia. An agent can investigate an outage, identify its root cause, and answer the question—but once the session ends, that knowledge disappears.

Months later, another engineer can make the same configuration change and trigger the same P0 outage.

ContextOS turns transient investigations into persistent, reusable organizational memory.

What it does

ContextOS is an agent-native enterprise memory layer built around a closed-loop cycle:

RETRIEVE → INVESTIGATE → REASON → CREATE MEMORY → REUSE MEMORY

  1. Multi-Source Investigation — Orchestrates tool calls across Slack, GitHub, Jira, and Confluence to build a causality graph.
  2. Root Cause & Recurrence Detection — Identifies root causes and detects similar failures across historical incidents.
  3. Institutional Memory Write-Back — Extracts verified safeguards and stores them as versioned Company Memory.
  4. Proactive Prevention — Checks memory when engineers investigate configuration changes and surfaces relevant safeguards before code merges.

How we built it

  • Frontend — Next.js 14, TypeScript, and Tailwind CSS with execution timelines, relationship graphs, and evidence drawers.
  • Hybrid Retrieval — BM25 + dense semantic similarity, recency decay, and service/tenant metadata boosting.
  • Agent Orchestration & MCP — Modular skills (search_knowledge, get_source, find_related, investigate, create_memory, search_memory) exposed through MCP JSON-RPC.
  • Persistent Memory — Atomic, file-backed storage with versioning, tags, safeguards, and reuse tracking.

Challenges

  • Cross-Source Causality — Linking commit hashes to Jira incidents, Slack threads, and documentation required structured relationship extraction rather than simple vector similarity.
  • Deterministic Hackathon Environment — Built a realistic, cross-linked enterprise dataset that demonstrates multi-hop investigation without requiring production OAuth credentials.
  • Memory-First Routing — Designed the agent to check institutional memory first for configuration queries while avoiding false positives on exploratory investigations.

Accomplishments

  • End-to-End Vertical Slice — Complete flow from multi-source investigation to memory persistence and proactive reuse.
  • Interactive Evidence Graph — Visualizes triggers, affected customers, triage discussions, and historical recurrences.
  • MCP Interoperability — Full MCP schemas plus an in-app JSON-RPC console for external agent integration.

What we learned

Conventional RAG is read-only. It can retrieve organizational knowledge but cannot preserve what the agent itself discovers.

The real shift is bidirectional memory: agents must not only consume context, but also turn verified discoveries into persistent safeguards that protect the organization over time.

What's next

  • Freshworks Connectors — Integrate Freshservice and Freshdesk to turn resolved incidents into verified memory.
  • CI/CD Guardrail Bot — Check GitHub PRs against institutional safeguards before merge.
  • Slack Incident Agent — Monitor postmortems and prompt SREs to preserve resolutions as memory.
  • RBAC Memory Pools — Isolated memory spaces for SRE, Finance, Security, Legal, and other teams.

Built With

Share this project:

Updates