A persistent learning runtime for AI agents.
Duplex is defining a new category.
It is not another memory database for your model. Duplex turns a temporary assistant, bound to one model, into a system that learns from the work, keeps its context, enforces your rules, gets better with your tools, shares what it learns with permission, and moves between model providers without losing what it has learned.
The missing fourth layer.
Today’s AI splits intelligence across three layers. The model reasons, retrieval supplies documents and memories, and application code runs the workflows, permissions and tools. None of them learns from the work. Duplex adds the fourth: learning from everything your agents do, kept for as long as you run it.
The model reasons about the task, and forgets it when the task is done.
What retrieval was never built to hold.
Retrieval brings back documents and memories that look relevant. Duplex keeps what the work has taught, and acts on it:
- 01What succeeded, and what failed
- 02Which actions led to which results
- 03Which tool works in which situation
- 04Which ways of working improved the results
- 05The preferences and rules still in force
- 06What each action changes
- 07The skills that repeated work has taught it
- 08What must be forgotten, reversed or withdrawn
- 09When it can answer on its own, and when to ask your model
Your AI is the model, plus what Duplex has learned.
The model can change. What Duplex learned stays.
Your AI
What your people and agents work with
The foundation model
Can change: a new version, a new vendor
What Duplex has learned
Stays: yours, and still growing
That separation changes what an organisation owns. What it has learned no longer has to live inside one vendor’s weights, one chat transcript or one app’s own memory format.
A new model arrives. On its own it starts from zero; with Duplex, it keeps everything learned so far.
For business: AI that compounds.
Duplex changes the economics of AI at work. Every confirmed result can make the next task better, and what builds up is yours to keep.
Value that compounds.
Most AI deployments start nearly from zero on every task. Prompts, retrieval and fixed workflows give context, but the system doesn’t improve from each confirmed result. With Duplex, every finished task can leave something behind:
- A better choice of tool
- A lesson in what an action changes
- A reusable skill
- A corrected decision
- A rule to keep
- A worked example
- A clear signal of what worked
- A faster way back into the work
- A new capability, tested before use
So the system grows more useful the more your organisation uses it.
Intelligence that moves with you.
Claude, Codex, Cursor and Hermes can all draw on the same Duplex, and so can your own agents, through MCP + hooks. Change the model, the agent client, the model provider or the tool vendor, and keep the processes, rules, history and skills your organisation has learned.
Lock-in falls, and what your organisation learns becomes an asset that lasts.
Personal, team and company, in layers.
Duplex keeps what it learns at every level that matters:
- One person
- A team
- The organisation
- One task
- A workspace
- An agent
- A shared thread
A person keeps their preferences and ways of working. A team builds shared practice and tool knowledge. The organisation sets the rules everyone works within, while people and teams go on learning beneath them. That is worth far more than one global memory.
Rules on what agents do, not only what they’re told.
Duplex rules govern what an agent actually runs, not just what a prompt asks of the model. Through MCP + hooks, Duplex takes part before each request, before each tool call and after each result, and whenever knowledge is shared or forgotten.
Enterprises need control over behaviour, not better wording.
Fine-tuning, for far fewer things.
Fine-tuning still matters when a model needs a new general ability or behaviour. But many business needs don’t require changing the weights at all:
- “Remember our release procedure.”
- “Learn which diagnostic tool resolves this failure.”
- “Stop recommending what keeps failing.”
- “Keep this customer’s constraint.”
- “Continue the task after we switch models.”
- “Share this proven process with the team.”
- “Withdraw what is no longer true.”
Duplex handles these outside the model: faster, reversible, traceable to their source, and usually cheaper than fine-tuning again and again.
A new moat.
The valuable asset is no longer only the model. The lasting advantage becomes this:
Your organisation’s continuously accumulated, governed, portable operational intelligence.
Two companies can use the same model and get very different results, because one has years of confirmed lessons, skills, rules, corrections, outcomes and task history in Duplex.
For research: continual learning, as a system.
Duplex treats continual learning as a systems problem, not only a question of how to update a network’s weights.
Learning that leaves the weights alone.
Much research on continual learning updates a network’s weights while trying to avoid catastrophic forgetting. Duplex takes another path, and adapts outside the model’s weights. It is still genuine continual learning: what it does next changes with what it has experienced. And it offers what weight updates struggle to:
- Exact attribution
- Learning that can be reversed
- Isolation between customers
- Selective forgetting
- A full audit trail
- Adaptation on the spot
- Far less compute
- No retraining downtime
Many ways of learning, run as one.
Duplex brings several kinds of learning together: adapting fast, recognising what is new, knowing how sure it is, predicting what an action will change, planning, learning from outcomes, and turning evidence into skills it tests before use.
The research value is not in any single algorithm. It is in running them as one persistent, governed learning system behind real agents.
Unlearning that reaches everything.
Forgetting is more than deleting a record. When the evidence behind something is removed, everything Duplex learned from it can be withdrawn with it. That matters for privacy, correction, safety, regulation and scientific validity.
A system that learns but can’t accurately unlearn is incomplete for anything meant to run for years.
Long work, without the whole transcript.
Duplex carries forward what a long task needs: its goal, its decisions, its constraints and the work still open.
Continuity doesn’t have to mean feeding the model the entire history again, and that matters for agents that work for hours or days.
Learning from more than words.
Duplex learns from images, audio, video and documents as well as text, under the same governance over what may be learned. Screenshots, designs, recorded conversations, documents and tool outputs can all teach it.
The point is not finding media. It is connecting that evidence to outcomes, tasks, skills and forgetting.
For the field: where intelligence lives.
Its biggest implication: intelligence no longer has to live entirely inside the foundation model.
A new unit of intelligence.
The usual view, and the one Duplex makes possible:
The model is the intelligent product.
The intelligent product is the model, plus a runtime that keeps learning.
Improvements can then build up between model calls, between sessions, and even between model providers.
Models become easier to change.
When memory, personalisation, rules, learned tool use, task continuity and an organisation’s own skills live in Duplex, the model underneath becomes easier to replace. Models still compete on reasoning, speed, modality and price.
But what a customer has built up no longer disappears when the model changes, and power shifts towards whoever holds what was learned.
Agents that stay themselves.
An agent connected to Duplex carries on as itself when:
- A conversation ends
- The context window fills
- The client restarts
- A task resumes days later
- The model changes
- Work moves from Claude Code to Codex
- Another authorised person joins
That is closer to a persistent software worker than to a string of unrelated chats.
A clear line between model and system.
ACI is the intelligence that adapts. Duplex is the product around it: the decisions, the governance, the ways in, and the life of everything it learns. Agents work with a few simple, stable operations, the model never needs to know what runs beneath them, and hooks tie each decision to a real action.
That line is what turns an engine into infrastructure that any agent can use.
Another way to scale.
The field often assumes more capable AI mainly needs larger models, more training data, longer context windows or more computation at inference. Duplex adds another dimension:
A capable model that keeps accumulating confirmed experience outside its weights.
That can do more, for less, than growing the model or its prompt again and again.
What Duplex is becoming.
Duplex makes AI agents remember, learn, improve, obey and continue, across sessions and models.
It is not just
- A vector database
- A memory plugin
- A prompt manager
- An MCP server
- A workflow engine
- A policy gateway
- A fine-tuning system
It combines parts of all of them into one runtime that learns.
Duplex beside memory, skills, fine-tuning and AI gateways →In short.
For business
AI that improves through use, and keeps what it learned across agents and model vendors.
For research
Continual adaptation, uncertainty, memory, planning, reversible learning and evidence from every medium, in one system working behind real agents.
For the field
Intelligence no longer has to live entirely inside the model. What is learned can become a separate layer: governed, portable and yours.
Infrastructure, not a feature.
The biggest opportunity is making continual learning work in practice: immediate, persistent, reversible, governed, and available to the agents you already use through MCP + hooks, with your model left as it is. Duplex is designed to be the layer where people and organisations build up their AI intelligence, while models become replaceable reasoning engines beneath it.
Own the intelligence that outlasts every model.
A pilot puts Duplex on your own work, with what counts as success agreed before it starts.