The Context Engine

Kadhir Manickam

(16 minutes)

<section data-section-id='86a72393-414d-4f2b-9838-ffe8352d6d4a'>Every company now has thousands of agents trying to get work done, and almost none of them know what the organization actually knows. The information exists. It's just scattered across Slack threads, PRs, call recordings, and the heads of a few tenured employees, unreachable by anything that isn't human. </section> <section data-section-id='b547dd8c-83f6-42c3-9e2a-f72fddbe286a'><h2 id="the-problem-organizational-context-has-become-a-big-data-problem">The Problem: Organizational Context Has Become a Big Data Problem</h2>That scattered record has a name: organizational context. It is the accumulated, decentralized account of what a company knows and decides (decisions, rationale, code, conversations, customer signals, institutional memory), and it lives spread across systems of record and tribal knowledge rather than in one place. After working with many companies, we've realized the core issue is getting the right pieces of it to an agent at the moment it acts, which is surprisingly hard, especially if you want autonomous systems that continually scale across the entire organization. And bringing all of that context together is rapidly becoming a big data problem, following the same 4Vs: <table><colgroup><col style="width: 92px;"><col style="width: 783.602px;"></colgroup><tbody><tr><th style="width: 75px; background-color: rgb(242, 243, 245); border: 1px solid black; vertical-align: top; text-align: start;">V</th><th style="width: 75px; background-color: rgb(242, 243, 245); border: 1px solid black; vertical-align: top; text-align: start;">What it means for organizational context</th></tr><tr><td style="width: 75px; border: 1px solid black; vertical-align: top; text-align: start;">Volume</td><td style="width: 75px; border: 1px solid black; vertical-align: top; text-align: start;">The sheer amount of context generated daily (Slack messages, PRs, call recordings, docs, tickets) has outgrown any human's ability to track it.</td></tr><tr><td style="width: 75px; border: 1px solid black; vertical-align: top; text-align: start;">Velocity</td><td style="width: 75px; border: 1px solid black; vertical-align: top; text-align: start;">The speed at which decisions, code, and product reality change, especially now that AI agents produce output faster than people can absorb it.</td></tr><tr><td style="width: 75px; border: 1px solid black; vertical-align: top; text-align: start;">Variety</td><td style="width: 75px; border: 1px solid black; vertical-align: top; text-align: start;">Context lives in structurally different formats and systems (chat, video, code, documents, tribal memory) with no shared schema connecting them.</td></tr><tr style="height: 50.4492px;"><td style="width: 75px; border: 1px solid black; vertical-align: top; text-align: start;">Veracity</td><td style="width: 75px; border: 1px solid black; vertical-align: top; text-align: start;">Much of what's recorded goes stale or gets contradicted (superseded decisions, abandoned patterns, outdated docs), so the truth is uncertain even when the record exists.</td></tr></tbody></table> To tackle this problem, we built a context engine. </section> <section data-section-id='417240ea-7997-4c39-bf33-e3ea128cb8e8'><h2 id="meet-the-context-engine">Meet the Context Engine</h2>A context engine is infrastructure. It's a system that continually pulls and reconciles information from every source that matters (systems, applications, people, and agents) into a single source of truth, specifically designed to address the 4Vs of organizational context. Two properties make it an engine:<ul><li value="1">Continuous reconciliation. It doesn't just store data once. It keeps pulling from source systems and resolving conflicts as they arrive, so the truth it holds stays current.</li><li value="2">Actionability. You can query it for answers and, just as importantly, act on it. That's what makes it the right substrate for running agents on top.</li></ul> And it isn't read-only: humans and agents can edit its content at any point, with every change version-controlled, so the truth is something both can write to, not just read from. </section> <section data-section-id='7d2d7453-23b5-41f6-a644-9cbd2640ff70'><h2 id=the-five-attributes-of-a-context-engine id="the-five-attributes-of-a-context-engine">The Five Attributes of a Context Engine</h2>Two properties make it an engine. Five attributes make it survive contact with the problem. Miss any one of them and the system degrades into a nicer-looking silo. Unified. One substrate, not a pile of connectors. Every source resolves to the same entities, so revenue means one certified thing, not three conflicting documents. Without this, every other attribute is undermined: three teams define the same metric three ways, and an agent asking for it picks the wrong one. A queryable, governed pile of silos is still a pile of silos. This is the attribute everything else stands on. Queryable. Ask it questions and get grounded, sourced answers, not a ranked list of chunks. Search systems return documents and leave the interpretation to the reader. An agent can't work with that, because the next step after a query is action, and acting on a misread chunk is worse than not acting at all. The engine has to return an answer the agent can ground on, with provenance attached. Governed. Every asset carries version history, ownership, and access controls, enforced live at query time, not set once at ingestion. A static catalog checks permissions once, when the data lands, and by the time anyone queries, the org chart has moved. Live enforcement checks on every read. Once agents query the substrate at machine speed and scale, that distinction is the whole game: one stale permission is a leak at machine scale. Living (synchronized). It stays current automatically as source systems change, so the knowledge inside reflects the world as it is right now, not as it was at last re-index. The failure mode of a stale substrate is quiet: an agent confidently acting on outdated facts, with nobody noticing until the damage surfaces downstream. Periodic re-indexing can't fix it, because the gap between indexes is exactly where the staleness lives. Continuous sync is the only version that works. Easy to contribute to (agent-ready). Friction is near zero for humans and agents alike, so context flows in as naturally as it flows out, and corrections propagate back into the substrate. A one-way context engine decays: context flows out to agents, but corrections never flow back in, so the same wrong fact keeps getting served. Agent-originated corrections need the same path as human ones. Contribution is what keeps the substrate alive between syncs. This framing lines up with how the category gets defined everywhere else: context layers, active metadata, enterprise knowledge graphs. We didn't invent the checklist. We built the system that actually checks every box. </section> <section data-section-id='0920b196-ef86-46fa-a5b4-57cba1b9ec44'><h2 id="why-now-the-multiplayer-ai-agent-forcing-function">Why Now: The Multiplayer AI Agent Forcing Function</h2>AI agents are the most capable collaborators ever built. They're also profoundly amnesiac: every session starts from zero, with no memory of what the organization has already figured out. That was tolerable when agents worked alone. It breaks down now that everyone's agents need to build on each other in a multiplayer first world. </section> <section data-section-id='26fe0d2a-b00b-4273-b102-4cf8a68c8621'>Getting agents to work together is hard, harder than getting a single agent to work well. The moment a second person or a second agent enters the picture, every private chat becomes a silo. One teammate solves a problem with an agent, and the next teammate starts from zero, because nothing about that session was ever shared, indexed, or made queryable by anyone else. That gap compounds with every handoff. A decision made in one session has to be re-explained, re-typed, or re-discovered in the next, and the organization pays that tax over and over. This is exactly why the substrate matters more than the agent. A context engine is what lets a decision made once become durable and accessible to every future session, human or agent, rather than being trapped in a transcript nobody else can see. None of this is easy to build. But the payoff, agents and people compounding on the same foundation instead of relearning it every session, is exactly why it is worth building. </section> <section data-section-id='57c447f7-a282-4a12-9612-0f3d8abb23b4'><h2 id="the-context-engine-in-two-layers">The Context Engine In Two Layers</h2>Everyone building in this space converges on the same idea: pull organizational context into one place so agents can use it. Our differentiator is the form the context takes once it lands, and the architecture that's been built around it. Our context engine is built in two layers, and the easiest way to understand them is to watch them work together. Layer one is the foundation. We quickly realized, working with many companies, that trying to build a new abstraction, a new interface here, was going to be an uphill battle. The average person does not want markdown or some new format. They want something they're already familiar with. Ask anyone what context looks like and they'll say text, and everyone already knows how to work with text: in a document editor. So the foundation is a record layer that looks and feels like a normal document in a normal web editor, while underneath it quietly does the substrate work: versioning, retrieval, provenance, permissions, all native to the record. Layer two is the agents, the active machinery that cranks on top of the foundation. The foundation holds context. The agents move it. Here is how the two layers run as one system. </section> <section data-section-id='26bdf21b-ac08-4c15-ad8b-7c7a2502d5d0'>It starts with your systems. The Self-Assembling Integration agent connects to each one and runs a two-way sync: external data flows in and lands in the record as native, queryable context, and when a decision gets made or a fact gets corrected here, the change pushes back out to the source. Connecting a new system is a submission, not an ETL project, and the record and your systems never fork. And the same agents plug into the surfaces your team already works in, so context flows in from where the work actually happens. We meet you wherever you already work: Claude, ChatGPT, Cursor, Slack, Teams. The integration agents plug into the tools your team already lives in, so nobody learns a new surface or forms a new habit. Everything that lands enters the foundation's life cycle. It arrives in our autoregression native record format that humans, agents, and indexes all read natively, so nothing gets translated or lost on the way in. An agent picks it up in its next session and refines it directly, because authorship is symmetric: its edits carry the same standing as a person's. When two authors touch the same truth at once, multiplayer conflict resolution keeps either edit from clobbering the other, and zero-copy retrieval reconciles each change against everything the record already holds, on the same step, cheaply. The result gets versioned, so you can diff what changed and roll back a bad edit. It gets stamped with its origin, who or what wrote it, and which system it reconciled from. And it gets permissioned from the moment it exists, access inheriting down the record and checked live on every read. Then the next two agents add the context your systems never held. The Closed-Loop Synthesis agent meets you in whatever meeting tool you already use (Zoom, Webex, Google Meet) and turns what happens there into record updates: a call ends, an incident closes, and the record reflects it before anyone opens a laptop, no transcription, no delay. The Latent Context Resolution agent goes after what was never written down anywhere: it identifies gaps in the organization, finds the people most likely to hold the answers, interviews them, and writes it back into the records, so it never has to be given twice. Every event and every answer that lands this way enters the same foundation life cycle as everything else. And if you turn it on, the Perpetual Recalibration agent makes all of it better over time. It trains a private model on the full record, inside your environment, every day, and ships the improvements back into the other three agents: integration converts external data more accurately, synthesis writes updates that match what actually happened, and latent resolution finds the right person more often. Everything gets more correct, more reliable, cheaper, and faster, entirely on your own data. That is the context engine working. Context flows in from your systems, lives a governed life in a record that humans and agents read and write together, gets enriched from events and from people's heads, and the machinery itself sharpens with every pass. And notice what had to change in how anyone works: nothing. No one switched tools, no one took notes, no one filed a document, no one learned a new system. The agents meet people where they already work and do the moving themselves. The stakes split the same way the architecture does: a context engine nobody can intuitively use never reaches critical mass, and one that needs humans to feed it never stays current. The foundation solves the first. The agents solve the second. The next section breaks each piece down in full. </section> <section data-section-id='d95be085-84f9-4cc9-b5cd-a05d6cc8c518'><h2 id="two-layers-in-detail">Two Layers In Detail</h2><img src="https://api.productnow-prod.com/storage/getStorageObject?storageObjectId=64725708-e3ae-4abf-be1a-65a5beb10832" alt="64725708-e3ae-4abf-be1a-65a5beb10832" data-alignment="center" data-card="true" width="1536" height="1024"></section> <section data-section-id='eef37c24-9f3f-4c8d-84ea-ccd9ebdbf4bd'>The foundation. The record layer, the substrate where all organizational context lands and lives. On the surface it is just a document in a familiar editor. The easiest way to see the substrate work underneath is to follow one piece of context through its life in the record, from the moment it is written to the moment it is read, corrected, and read again. Seven properties make that life possible, and each one sets up the next.<ul><li value="1">Autoregressive-Native Record Format. It starts with the record itself. Humans, agents, and our indexes all read the same underlying data format, with no translation layer in between. Standard docs and wikis were built for people skimming linearly, not for models generating and parsing structure. Without a native format, every read becomes a one-off parsing problem, and every agent works off a lossy copy instead of the record itself.</li><li value="2">Symmetric Authorship. Because humans and agents read the same format, both can write it. Agents reason about and edit our documents without any human intervention, in a way that scales as models improve. If agents can only read the record, the record decays. That symmetry is what lets the system compound, because every agent session leaves the substrate richer than it found it.</li><li value="3">Infinite Multiplayer. Once both can read and write, they have to write together. The majority of our documents are written by agents, and they have to play nice with each other and with any human authors editing concurrently. Real conflict resolution is what keeps concurrent edits from clobbering each other, so the system never silently loses truth. This is multiplayer editing extended to non-human authors, across massive amounts of shared data, not just concurrent viewing.</li><li value="4">Zero-Copy Retrieval. With that many authors writing at once, reconciliation runs on retrieval. Agents and humans pull the most relevant, up-to-date information on every step, which is how they resolve their work against what the record already holds. Retrieval is native to the record, not a bolted-on vector index synced after the fact, so nobody ever queries a stale shadow copy. And it stays cheap enough to run on every agent step, not just the first one.</li><li value="5">Time-Travel Versioning. Every one of those writes and reconciliations is version-controlled. Documents snapshot cleanly, capturing version history with semantic meaning, not just edit history, so humans and agents can walk back to any prior state. Git-like versioning is what lets you diff what changed, roll back a bad agent edit, and reconstruct why a decision was made. Without it, there is no accountability for anything an agent writes.</li><li value="6">Certainty of Origin. And every version is traceable back to its origin. Provenance records whether a human or an agent wrote something, which agent wrote it, and which source system it reconciled from, so we can maintain trust with external systems. Without it, trust collapses the first time an agent hallucinates something into the record, and nobody can tell.</li><li value="7">Inheriting Governance Graph. Finally, it's all permissioned. Agents need to operate across systems of record to be maximally useful, so we enforce authorization within our system to ensure they can operate safely and securely across those organizational boundaries. Access inherits down the hierarchy of the record and is checked live on every query, so a section carries the right restrictions even when the source system's permissions don't map one-to-one, and no read ever escapes its governance.</li></ul>That is the life of a piece of context in the foundation: written by anyone, reconciled by everyone, versioned, traced, and governed at every step. </section> <section data-section-id='811a00de-03a1-49a6-9b08-c453e492f481'>The agents. The foundation gives context a place to live. The agents are what connect that record to everything around it. Each agent owns one interaction surface with the rest of the company: your systems of record, events in the world, people's heads, and the models themselves. Context flows in across all of them, and where the outside world needs to catch up, it flows back out. Each one rides specific properties of the foundation.<ul><li value="1">Self-Assembling Integration. The first surface is your systems of record, and the connection is a two-way sync. Inbound, the agent pulls external data out of every connected system and leverages an array of agents to convert it into native, queryable context records. Outbound, it uses a separate set of agents to write back from the record into those same systems, so when a decision is made, or a fact is corrected, the change pushes out to the source and the two never diverge. Connecting a new system is a submission, not an ETL project, because the agent maps the system's schema onto the record and keeps the sync alive as that schema drifts, keeping context in sync and live everywhere it goes.</li><li value="2">Closed-Loop Synthesis. The second surface is the world itself. When a call ends or an incident closes, this agent turns what happened into record updates, with no human transcribing anything. The record is where the event lands, so the next human or agent who reads it works from what actually happened, not from the last time someone took notes. The loop closes because what happens and what the record says never drift apart.</li><li value="3">Latent Context Resolution. The third surface is people's heads. Most organizational context is tribal, knowledge that was never written down anywhere. When the record is missing something an agent needs, this agent fills the gap from both ends: it identifies the person most likely to hold the answer, asks them, and writes what comes back into the substrate. The human gets a question instead of a documentation task, and the answer never has to be given twice.</li><li value="4">Perpetual Recalibration. The last surface is inward, the models themselves, and this one is optional. The foundation and the other three agents run complete without it; you turn it on to get the compounding benefits. What you turn on is a private training loop: the agent trains on the full set of records in your foundation, inside your environment, just for your organization. Your data never leaves your environment, never trains a shared model, and never mixes with anyone else's. Every day, the improved models ship back into the other three agents. Integration agents convert external data more accurately, the synthesis agent writes updates that match what actually happened, and latent resolution finds the right person more often: correctness and reliability go up, cost and latency come down. And because the training set is your living record, your models keep pace as the business changes instead of going stale after one training run. The system gets sharper, faster, and cheaper the longer it runs, entirely on your own data.</li></ul> That is the full loop around the foundation. Context flows in from systems, from the world, and from people, and changes flow back out to the systems they came from. Every pass leaves the record richer than the last, and leaves the rest of the company in step with it. The dependency runs in both directions: the foundation is what makes the agents possible, and the agents are what keep the foundation fed, current, and honest. </section> <section data-section-id='0b48fd32-b5ba-4ad1-9405-c5c3f7d9cf7f'>Neither layer works alone. The foundation without the agents is a well-governed archive. The agents without the foundation are automation with nothing trustworthy to act on. Together they close the loop this entire piece has been tracing: the foundation gives everything that flows in a governed place to live, and the agents keep those flows moving without being fed. Zoom out and that loop becomes the company itself. Context flows in from every system, every meeting, and every person's head, and lands in one living source of truth that humans and agents read and write together. Every change is versioned, every claim is traced to its origin, and every read is permissioned. Each decision, each meeting, each agent session feeds back into the record, and the next one starts smarter than the last. Knowledge stops decaying and starts compounding. Improvement stops being an initiative and becomes a property of the system. <callout icon="rocket" color="#F59E0B">The context engine makes every company continually and automatically self-improving</callout>Want to learn more? Shoot us a note at <a href="mailto:hello@productnow.ai" rel="noreferrer">hello@productnow.ai</a>. </section>