I started noticing the gap in late 2025. Every morning, the AI I'd spent hours with the night before knew nothing about me. Every new chat started from zero. Every fork of a problem became its own island. I'd switch from Claude to ChatGPT to investigate something the other couldn't, and neither knew what the other had said. I'd jump from laptop to phone and lose the thread. My engineers were doing the same. My lawyer too. My ops lead.
Memory in AI tools is broken in a particular way. It's not that the models forget — most modern models retain context across long conversations. It's that the substrate forgets. The thing underneath the model — the conversation history, the cross-session continuity, the cross-tool linkage, the cross-device persistence, the cross-teammate sharing — that layer is missing. Each AI tool has its own memory, scoped to its own surface, locked behind its own walls. When you switch tools, change devices, restart a session, or hand off to a teammate, the memory doesn't follow.
Cynapa wasn't an academic exercise. It came out of building Kachyng — agentic commerce infrastructure that lets AI agents pay. A 180-repository platform built on four pillars: IDX (identity and cryptographic delegation), AGX (agent gateway and orchestration), KYA (runtime risk and trust evaluation), and PRX (processor exchange across hundreds of acquirers). All of it bound by PCI DSS Level 1 and SOC 2 Type II compliance, supporting card-present, card-not-present, e-commerce, and autonomous agent execution.
The core stack is roughly 9 million lines of code. Another 15 million lines of supporting applications around it. Dozens of engineers across half a dozen product domains. At that scale, the problems with how AI tools "remember" the work stopped being inconveniences and became operational tax.
Every Kachyng transaction passes through all four pillars. The agent's delegation is signed in IDX, orchestrated through AGX, gated by KYA, routed by PRX. Every step depends on state from the previous step — and the whole flow has to align cryptographically and produce a compliance-ready audit trail. Memory across these systems isn't a feature. It's the precondition for the platform working at all.
The math is unforgiving. At an average of about 10 tokens per line — depending on language and verbosity, somewhere between 6 and 20 — a 9-million-line codebase is roughly 90 million tokens before you've added a single comment, ticket, design doc, or runbook. Even working against a third of it, you need a model with a 30 to 50 million-token context window to hold the cross-references that an engineer holds in their head without thinking. No model has that window. None is close. None will be, soon.
So our engineers did what every team does. They re-explained context to the AI every morning. They kept Markdown files, prompt rules, hand-curated pointers. They watched decisions made on Monday get re-litigated on Wednesday because the agent had no memory of the Monday session. They watched the AI bill compound — the same questions answered ten times across the team. They felt the failure mode personally, daily, repeatedly, for months. Then they told me they were doing it. Then my lawyer told me she was. Then my ops lead.
That's where the diagnosis sharpened. Cynapa is what we built to fix it for ourselves first. The substrate is what Kachyng's pillars are being wired onto — IDX delegations, AGX orchestration steps, KYA risk decisions, PRX processor routes, all destined for one continuous memory underneath. The wiring is in progress; the architecture is what's resolved. What's being built for a 180-repo agentic commerce platform under PCI Level 1 and SOC 2 obligations is what will work for any other organization at scale. Kachyng is the proving ground. Cynapa is the layer that came out of it, and that goes back into it.
AI vendors don't connect their memory to other vendors' memory because the memory is a moat. Every conversation that lives only in their tool is a customer who has trouble leaving. Every context built up in their system is switching cost they own. The vendors aren't going to fix this. They have no incentive to fix this. The longer you use them, the more they benefit from your memory being stuck in their walls.
The same thing happened in every prior wave of enterprise software. Files lived in one application's format. Email lived in one server's database. Customer records lived in one CRM. Each generation of tools held its data hostage until something underneath broke the silos open. File systems became standardized. Email became a protocol. Customer data became APIs. The capture moved from inside the tool to underneath it.
AI is at that same moment now. The capture is still inside the tools. It hasn't moved underneath yet.
The architecture is straightforward to describe and hard to build. You ingest events from every AI tool a person or organization uses — conversations, agent runs, tool calls, document edits, code commits, meeting transcripts, browser sessions, calendar entries, communications. You resolve identities across substrates so the same person, the same artifact, the same project, the same decision is recognized across every silo. You segment the work into topic spans and workstreams that survive the surface they originated on. You build a memory graph that everyone authorized to see it can query the same way. You enforce permissions structurally so that what you're allowed to see is a coherent slice of the graph, not a redacted projection.
When you do this right, several things stop being true.
Memory stops being a feature inside any single tool. It becomes infrastructure under all of them. Every AI a person uses participates. None of them owns the substrate.
Switching between AI tools stops being expensive. Your memory comes with you. The tool becomes a surface for accessing memory rather than a vault holding it.
Continuity across devices stops being a manual chore. The same workstream is accessible from laptop, phone, vehicle, voice surface, or whatever comes next. The work follows you, not the device.
Redundant inference stops being invisible cost. When ten people in a company ask the same question of the same model in the same week, the system knows. The first answer becomes a memory. The next nine become retrievals.
Agent decisions stop happening in the dark. Every agent action — every tool call, every cross-agent message, every decision made on your behalf — becomes a queryable event in the same graph as your own work. The most consequential thinking in your company stops being invisible.
Three things changed at the same time. AI capability crossed the threshold where serious people use it for serious work. Multi-vendor usage became normal — most knowledge workers now use two, three, or more AI tools regularly. And agents started making real decisions, calling real tools, running real workflows, often without any human present in the loop. The combination of those three shifts created a memory problem that didn't exist five years ago and won't be fixable five years from now without infrastructure that doesn't yet exist today.
So we built it.
Cynapa isn't trying to replace your AI tools. It works above them. Cynapa isn't trying to replace your enterprise systems. It connects to them. Cynapa isn't trying to be smart on its own. The intelligence is in the agents and the people; Cynapa is the substrate that lets them operate as one mind.
If we do this right, no one notices Cynapa most of the time. They notice that their AI remembers them. They notice that their work follows them across devices. They notice that their teammates can pick up where they left off. They notice that their AI bill stops compounding. They notice that the agents in their company are accountable in a way they weren't before. The substrate itself is invisible. The effects of the substrate are everywhere.
That's what we're trying to build.
— Resh Wallaja