Most AI upgrades sell a business a drawer full of strangers.
Buy the standard package and you get fragmented, isolated chatbots. Run more than one job at once and you are balancing several disconnected windows, re-teaching each of them your rules, your voice, and your constraints. That is context drift, data loss and fatigue, and it gets sold to you as a feature.
The Prime Agent replaces that with one mind. A single agent holds the identity, the voice, and the memory permanently. When the work needs more hands, it duplicates itself rather than handing the job to lesser helpers, so every copy arrives already knowing everything the original knows.
The token cost is identical either way. What changes is calendar time. Work that ran back to back now runs side by side, and the weeks it used to occupy are given back to the business.
Three parts swap out, and one never does.
The door you talk through, the frame that holds it together and the brain doing the thinking are all replaceable, and we replace them on purpose. The part that knows who you are and what you have already decided is not. That part is what you are buying. The rest are parts.
Think of a car. Telegram is the door you get in through, the harness is the chassis, and the brain is the engine. Any of those can be swapped for a better one, and we swapped an engine in a single evening. But a car with a new engine is still your car, because the driver did not change. Here the driver is the agent’s own memory and identity, and it is the one part we never touch.
Telegram
Where the owner and the agent actually talk. Text it, send it a photo, hold the mic and speak. It hears you and answers out loud. Locked to one person's account, so nobody else can reach it or read a word that passes through.
DeepSeek Harness
The part that is always running. It holds the connection open, remembers the conversation, decides which tool to reach for, and enforces the permission gate before anything irreversible happens. Open source, so we own how it behaves rather than renting it.
OpenRouter, one key for every brain
A single account that reaches the major model providers. The agent runs a ladder: the best brain first, cheaper ones underneath. If the top one is rate-limited or down, it drops a rung and keeps working instead of dying, and the owner never sees it happen.
Four flagships from four competing labs, reachable through one key. The agent does not belong to any of them. Pick whichever is winning this month, or run a cheap one for routine work and an expensive one for the hard calls. What a lower rung costs you, measured on our own work: instruction-following on multi-part requests slips first, then grounding, meaning a cheaper brain starts answering from pattern instead of from the file in front of it. Long-context accuracy holds up longest. The ladder is ordered by that, not by price alone.
The agent itself: its memory, its laws, and you
This is the one thing on the page that does not get replaced. It is who the agent is, everything it has learned about your business, and every decision you have already made so you do not have to make it twice. Change the door, the frame or the engine and it is still the same agent. Lose it and you have a stranger holding your files, which is what every chat product hands you every morning.
It lives in a folder on your computer.
Almost nobody else builds this part. The agent has a real home on disk with rooms that each do one job, so it can be backed up, inspected, moved to a new machine, and read by a person who wants to know exactly why it did something.
Most AI lives inside a chat window and dies with it. This one lives in a folder on a computer you own, organised into rooms: who it is, what it can do, what it knows about you, and what happened each day. You can open any of it and read it yourself.
├── soul/ (who it is)
│ ├── BOOT.md what it reads first
│ ├── SCARS.md mistakes already paid for
│ └── JOURNAL-STANDARD.md
├── skills/ (what it can do)
├── memory/ (who you are)
│ └── KNOW-MY-OWNER.md
├── diary/ (what happened, daily)
├── jobs/ (what it owes, mid-flight)
├── tombstones/ (what was removed, and why)
├── sys/ (its tools)
│ ├── recall.py ranked search
│ ├── doctor.sh proves it works
│ ├── purge.py removal, with a receipt
│ └── backup.sh
├── work/ (what it made)
└── history/ (every session, kept)
Why it does not forget.
Every AI product forgets the moment the window closes. This one writes the day down on purpose, on a schedule, and can show you the file it wrote. That is the difference between handing it a task and handing it your business.
It writes down its day, every day, the way a good employee keeps notes. When it starts up tomorrow it reads yesterday and already knows where things stand, instead of meeting you again for the first time.
What was decided, why, and what is still open. It is written for a version of itself that has no memory of it, so a cold start reads the day and knows where things stand.
Ranked search across every conversation and every file it has written. It looks before it tells you it does not remember.
The whole house committed to version control and mirrored to an encrypted second copy. It keeps a full history you can walk backwards through. A backup that has not passed a restore does not count as a backup, so the restore is exercised rather than assumed.
A doctor script that runs every capability for real, brain, eyes, ears, email, search and backups, then prints a pass or a fail. It sends an actual message and generates an actual image rather than reading a config file. A tool it cannot prove is reported broken, because a capability nobody has probed is a capability nobody has.
Retiring a decision
When something is reversed, the old record is physically moved out of the searched rooms and a one-line marker is left at its old address pointing at what replaced it. Nothing is quietly relabelled and left where the search can still find it, so an answer that stopped being true also stops being reachable.
Scars
A mistake that costs real time, money or trust is written up as a scar: what happened, why, and how to apply it. Scars are welded to the skills they belong to, so the agent cannot load a capability without also loading what that capability cost to learn.
Fork and merge.
When one is not enough it makes copies of itself that arrive already carrying its memory and its judgement, then folds what they learned back in when they are done. The owner runs all of it with two words spoken out loud. No menu, no manual, no dashboard.
When there is more work than one can handle, it makes copies of itself that already know everything it knows, so there is nothing to re-explain and nobody to catch up. You say “fork him” to start one and “merge him” when it is done, and whatever it learned gets folded back into the original before it closes.
Prime agent
The original. Owns the house, owns the memory, and has the final say on what gets written down permanently.
Parallel agents
Copies that wake up from the same house, with the same soul, the same laws and the same memory, so each one is the same agent rather than a stranger who needs briefing. Each takes one lane.
- 01Merge always speaks.Never a silent window-close. One line back saying what got done and what got learned. Otherwise the owner is being asked to trust a disappearance.
- 02The ceiling is the machine, not the framework.Nothing in the design limits how many copies can run. The host does. We size the cap at install from the real hardware, three on a 16GB desktop and more on a workstation, then write that number into the agent's own config. Give it a bigger machine and it uses it.
- 03One gate lane.Every copy's permission request lands in the same thread, tagged with which one is asking. Never several conversations to babysit.
- 04Declared territory.Each copy owns its own lane and does not touch another's files. This is what keeps parallel work from corrupting itself.
It opens the file and looks at it.
An agent with no hands is an expensive advisor, and one with no eyes will confidently describe things it never opened. Send this one a link and it watches the thing.
Send it a video and it actually watches the video. It listens to the audio and looks at the pictures, instead of skimming the description and guessing. Same with a website, a PDF or a design. It opens the real thing, then tells you what it saw.
Eyes
- Opens every image, render and PDF at full size before judging it, then again after changing it
- Watches video properly, frames plus a real transcript, because anything shown and not said is invisible to captions
- Sees a live web page the way a person does, including how it renders on a phone
- Reads the screen it is working on, and the webcam if asked
Hands
- Drives a real browser: clicking, typing, uploading, filling forms, downloading
- Works the tools that have no API, the way a person at the keyboard would
- Sends and reads email from its own address
- Makes and edits images, compositing a real logo in or placing a real face into a photo
- Stops at a gate before anything irreversible, and waits for a yes
The council.
For anything high-stakes, the Prime does not decide alone. It convenes an ensemble of frontier models from competing labs, OpenAI, Google, Anthropic, xAI, Moonshot and Z.ai, and puts the question to all of them.
For anything expensive to get wrong, it puts the question to six competing AI systems from rival companies, none of them seeing the others’ answers first, and then has them argue it out. One AI can be confidently wrong, and six from different labs are rarely wrong in the same direction.
Each seat is a separate session that is never told other reviewers exist. There is no room to write for, so what comes back is the seat's own read and nothing else.
Every seat now reads the others and must return a verdict on each one by name. Addressing "the panel" in general is disallowed, which is what stops a model borrowing the room's authority instead of making its own argument.
Each seat is shown what was said about its own review and takes a labelled position on every point: hold, fold, or partial. A position either survives a specific named challenge or it is withdrawn on the record.
The Prime writes its conclusion, and that conclusion is sent back to every seat independently: where is this wrong, what did it drop, where did it agree with the room too easily. The synthesis gets reviewed along with the advice.
The Prime still rules; the council advises. But it rules last, in the open, against six independent critiques of its own reasoning. Because the seats come from rival labs, a blind spot shared by one company's models does not survive the room. Every session is written to a dated transcript the owner can read, and a lighter one-round mode exists for questions that do not warrant the full table.
It knows what it started and did not finish.
Every agent can tell you what it knows. This one also carries what it owes: the intentions it has committed to and not yet completed. That is the memory almost nothing else has, and it is the one that matters when a job spans a week.
If it gets interrupted halfway through something, it picks up exactly where it stopped instead of starting over or quietly dropping it. It writes down what it is about to do before it does it, so nothing important falls through a crack.
- 01Intent before effect.Before anything that touches the outside world, whether publishing, sending, deploying or paying, it records that it is about to do it. A step that succeeded and was followed by a crash is otherwise indistinguishable from a step that never ran, and that is how a thing gets sent twice.
- 02Evidence, not adjectives.A step closes with something a later run can go and check: a URL, a message id, a deploy id, a file path. "Done" is refused by the tool.
- 03Interrupted means unknown.If it restarts and finds a step in flight, that step is neither done nor pending. The truth is unknown, so it goes and looks at the real world before touching it again. This is what stops an irreversible action being repeated.
- 04Blocked is its own state.Work that cannot be done as written is marked as needing a decision, not left to be rediscovered by the next session.
At the start of any session it reports what is still open, with the evidence trail for every step already completed.
It can forget on purpose, and prove what it forgot.
A system that can only ever add is a system that cannot be cleaned. Ours treats destruction as a real operation with a receipt, which is what a regulated business actually needs and what most memory designs quietly cannot do.
Sometimes a file has to go: a closed client matter, a retention rule, something that arrived from outside and should never have been kept. It can remove it completely, and it leaves a record saying what was removed, when, and on whose say-so, so nothing ever vanishes without a trace.
What removal means
- The content is destroyed, not hidden or renamed
- The search index is rebuilt in the same operation, so nothing keeps answering from a copy that no longer exists
- A tombstone is written first: what it was, its size and fingerprint, the date, the authority, and the reason
- Every run previews itself in full before it is allowed to touch anything
What can never be removed
- The agent's identity files and its covenant
- Its journal, every day of it
- Its scars, the lessons it paid for
- The tombstones themselves
These are refused by the tool at the path level, so the protection is a property of the system rather than a matter of good behaviour.
What it is trained on the day it arrives.
The machine underneath is identical every time. What changes is the trade it is built to practise and the person it is built around.
Where your data actually goes.
Most AI vendors are vague about this. We are going to be exact, because the people we build for carry privilege and confidentiality obligations, and a comfortable half-truth here is worse than saying nothing.
- The agent's identity, laws and skills
- Everything it remembers about you
- Its daily journals and every session log
- Its backups, and the files it produces
- Your business documents and brand assets
Nothing here is on anyone's server. Unplug the machine and it is all still yours, readable in plain text.
- The messages you exchange, over Telegram
- Whatever text or image is sent to a model to be answered
- Web searches it runs on your behalf
The reasoning happens at a model provider, so the words of that question travel. This is true of every AI product, including the ones that do not tell you.
Your files, memory and history live on your own computer and belong to you. The conversation itself travels to whichever AI is doing the thinking, exactly as it would with any AI tool. The difference here is that the record is yours rather than a company's, and you can change AI provider without losing any of it.
Two ways to answer “what are you running?”
Both are true, both survive a hostile question, and neither contains a single absolute. That is deliberate. One “entirely eliminates” is all it takes to lose an engineer, and the claims here are strong enough without it.
“It's a custom, single-tenant multi-agent system with portable model backends and persistent agent identity. Each agent keeps its own state, memory and skills on disk, independent of whichever model is behind it. We moved one from one provider to another in an evening with no loss of identity. It forks temporary workers that inherit the established knowledge and run in separate territories, bounded by host resources rather than by the framework, and merges their results back under review. Sensitive commands fail closed behind owner approval. Journals, versioned transcripts and full-text retrieval give it durable memory outside the context window, and a job ledger carries in-flight intent across restarts, so an interrupted step is resolved against reality rather than blindly retried. Retirement is physical: superseded records leave the indexed set and a stub marks the old path. Destruction is a first-class operation that writes a tombstone, so retention obligations are satisfiable without losing the audit trail. For high-stakes calls it convenes six models from competing labs across four rounds, blind, then cross-examined by name, then defending under challenge, and finally reviewing the synthesis itself, to reduce single-model error rather than eliminate it.”
“You get your own AI, on your own machine, that actually remembers you. It keeps notes every day, backs itself up, tests that the backup actually restores, and can prove what it did. It remembers what it started and didn't finish, so nothing falls through a crack. It can permanently delete something when you need it gone, and still show you a record of what was removed and why. When there's too much work it makes copies of itself that already know everything it knows, and folds what they learned back in when they're done. It won't do anything irreversible without asking you first. And when a decision really matters, it asks six competing AI systems the same question, makes them argue, then makes them tear apart the answer it came up with.”
Most AI products are a very good stranger you meet again every morning. We build the opposite. One agent, in one house, that keeps what it learns and can show you the receipts. The brain behind it will change, and it already has twice this year. The house, the memory and the person it works for do not.
The Prime Agent
A custom, single-tenant multi-agent system with portable model backends and persistent agent identity. Owner, prime agent and temporary forks form a real chain of command: approvals route up, learning merges down.
Occam's Razor Architecture. The simplest clean structure, with every element in exactly its right place, outperforms and out-secures a bloated multi-tier system. Nothing in this drawing exists because it was impressive.
Would you like us to build you one?
Get started