Operational memory for AI engineering.
Your coding agents work in the dark. We give them the brain your company already has — owners, release rules, prior incidents, runbooks — drawn live from GitHub, Linear, Notion, and Slack. With citations, source permissions, and approval gates built in.
TaskImplement ENG-1842 — guard checkout retry capture
Likely servicecheckout
Ownerspayments-eng
Likely reposacme/checkout
Prior related- INC-2117 incident — duplicate captures on retry
- #4031 pull request — added idempotency keys, missed retry path
- ENG-1607 issue — agreed on ledger-first retry order
Release ruleevery PR touching /retry/ must add tests/retry/*.spec.ts
Active skillreview_pr_for_service@v1.2 — drafts PR review comments; approval-gated
Redactions1 Slack source above allowlisted channel scope
Your agents are working blind.
Owners are implicit.
Your team knows that #payments-oncall ships checkout and that Alice has signoff on schema changes. The agent doesn't — and CODEOWNERS only covers part of it.
Decisions are buried.
The reason you chose retries-with-budget over a circuit breaker lives in a closed PR comment from Q1, a Notion doc nobody updated, and a Slack thread the agent will never see.
Permissions are tribal.
GitHub, Linear, Notion, and Slack each enforce their own access. A “knowledge base” that ignores that distinction is a security incident waiting to ship.
An agent assigned a Linear issue can read the issue and the repo. It doesn't know that #payments-oncall owns deploy approval, that the same problem broke checkout last quarter, or that the release rule rejects deploys after 4pm Friday.
What it isAn operational memory layer for software organizations.
The Context Company captures source events as immutable evidence, normalizes them into a permission-aware knowledge model, compiles task-specific context packs and reviewed skills, and exposes those to your agents over REST and MCP. Outcomes feed back as proposals — never as silent updates.
01
Capture
Webhooks + bounded backfills, stored raw before anything touches them.
02
Normalize
Artifacts, entities, claims, timelines, ACL grants.
03
Compile
Task-specific context packs and versioned skills, with citations.
04
Expose
REST and MCP, same authorization, no tenant IDs in payloads.
05
Learn
Agent runs feed memory proposals — owners review before promotion.
Three workflows on day one.
01
Linear issue → agent context pack
When a Linear issue is assigned to an agent (or a human asks for context), the agent receives a context pack: likely repos and services, owners and reviewers, prior related PRs and incidents, applicable specs and runbooks, test and release rules, known pitfalls, and the active skill version for the task — with citations and any source redactions called out generically.
Linear issue→context pack
02
PR review context
When a PR opens or moves to ready-for-review, the agent receives owners, prior related PRs, related decisions, release rules, and relevant incidents. It can draft a review comment — but no comment posts without an explicit human approval.
GitHub PR→draft review comment
03
Incident → runbook memory
When an incident closes (a Linear incident issue, a Notion incident doc, an allowlisted Slack channel), candidate runbook updates and service facts are extracted with citations and confidence, and routed to owners for review. Nothing gets promoted into durable memory without a review.
Incident close→owner-review proposal
This is not enterprise search.
If your last “AI for engineering knowledge” project failed, this is usually why.
Naïve “AI knowledge base”
The Context Company
Chat over a static doc index
Live operational memory tied to real source events
Ungrounded LLM summaries
Every claim cites its source artifact
“Uploaded files” permission model
Source ACLs flow through — agent sees what the user could
New facts overwrite silently
Memory proposals reviewed by owners; conflicts surfaced
One-shot context dump
Task-specific context packs and versioned skills
Agent posts whatever it wants
Approval-gated writes; no agent posts uncontrolled
A general-purpose search engine over your docs cannot answer “should an agent ship this.” Operational memory can.
Trust modelBuilt for agents you can actually ship with.
◇
Evidence-first.
Every claim in every context pack cites the artifact it came from. No invented facts. No ungrounded summaries.
◇
Permission-aware.
If a user can't read the Notion page, neither can the agent context pack derived from it. Source ACLs flow through to derived memory; mixed evidence defaults to the most restrictive ACL.
◇
Review-gated.
Memory updates from agent runs are proposals, not facts. Owners approve before promotion; fact conflicts and temporal contradictions are surfaced for review, not silently overwritten.
◇
Approval-gated writes.
Agents draft PR comments, Linear comments, and Notion pages. No agent posts without a human approval. No code pushes, no issue state changes, no deploys — by design.
- Tenant isolation:
- Postgres RLS, deny-by-default
- Source ACL evaluation:
- pure, in @context-company/core
- Prompt injection + secret sanitization:
- shared sanitizer across compiler, DB, MCP, web
Plug it into the agents you already ship with.
MCP, day one
/mcp endpoint
Tools for searching memory, fetching entity and service context, traversing the entity graph, reading current facts, retrieving the current skill version, creating context packs, proposing memory updates, and recording task outcomes. Same authorization checks as REST.
search_company_memoryget_entityget_entity_graphget_current_factsget_service_contextget_skillcreate_context_packpropose_memory_updaterecord_task_outcome
REST, same shape
/api/v1
Everything MCP exposes plus admin operations: context-pack lookups, entity reads, graph and fact reads, skill lookups, memory proposal lifecycle, agent run recording, audit events, sync status.
Versioned skills
Skills are built like specs, not prompts.
Each skill carries purpose, when-to-use, required inputs, retrieval rules, allowed tools, approval gates, verification checks, rollback / escalation paths, citations, owner, and last-validated date. Skills are republished through a draft → eval → review pipeline, not edited in place.
Connected to the sources you already work in.
GitHub
GitHub App with least-privilege permissions, webhooks for PRs / reviews / issues / workflow runs / deployments, bounded backfill.
Linear
OAuth2, webhook ingestion, Agent API support.
Notion
Integration scoped to explicitly shared pages and databases. Rate-limited sync respects Notion's request limits.
Slack
Events API on allowlisted channels only. No broad workspace backfill. Slack-derived claims always require owner review.
No Jira, Confluence, Drive, Zendesk, PagerDuty, Datadog, or meeting transcripts on day one — by design. We're building company memory, not a data warehouse.
Roadmap, in flightThe brain gets sharper as your team ships.
Skill learning loop
Repeated agent successes and failures generate draft skill updates with eval cases — evaluated against historical traces and gated by owner review before they ever ship to a single agent run.
Brain maintenance loops
Scheduled checks surface stale runbooks, missing graph edges, unresolved fact conflicts, embedding drift, and retrieval regressions. Safe operational gaps (embedding refreshes, normalization replays, projection rebuilds) auto-heal idempotently. Anything semantic is proposed for owner review, never silently edited.
Pilots open now.
In scope for pilot.
- GitHub, Linear, Notion connectors
- Optional opt-in Slack channels
- Linear → context, PR review, incident → runbook workflows
- REST + MCP
- Admin dashboard with approval queues
Out of scope on day one.
- Code pushes, branch creation, issue state changes
- Source document edits
- Deploys
- Any autonomous source writes
- Jira / Confluence / Drive / PagerDuty / Datadog / meeting transcripts
Book a pilot conversationWe're looking for engineering orgs already running coding agents who want company-aware memory under them. 30 minutes, no slides.