Deploys go through Railway. Not Vercel.
The memory your agents were supposed to come with
Every session they meet your company for the first time and pretend otherwise. Basemode gives them one memory that actually knows what things are — your decisions, your rules, your work, what it all means and how it connects — and feeds it to them the second they need it. Same agents. Ten people start working like thirty.
The same question, twice
Both runs used the same model, the same repository and the same prompt. The only thing that changed is whether anything put the answer in front of it before it started guessing.
❯where do we deploy the worker service?
This project deploys to Vercel — vercel.jsonis present at the root. I’ll add the worker service there.
❯where do we deploy the worker service?
basemode · placed before the model answered
Railway. vercel.json is leftover from before the March decision — the worker goes to Railway with a Procfile.
the one on the left is doing everything you would ask of it, and it still hands you the wrong answer.
Why it speaks first
This is the part everyone else leaves up to the model, but an agent cannot go looking for something it does not know exists. So it does not go looking at all. It guesses instead, and it guesses in complete sentences with excellent grammar.
Session start
Everything standing that governs where they are about to work.
At the prompt
Whatever bears on the thing they just asked for.
Before a tool runs
The rule that governs this file, placed before it gets edited.
After it returns
What the result means here, while it still matters.
Every injection is a query against the moment, so opening a billing file returns the billing rule, the decision that got reverted and the gotcha, and nothing else. You stop paying for a context window full of hedge, and the model stops drowning in its own briefing.
Most of the time it speaks first and nobody has to ask for anything. But when someone does want to ask a question directly, they can, and the answer comes out of the same place. There is no second system keeping its own version of the truth, so what you get when you ask is what your agent already got when it did not.
Why everyone else gets smarter
Fifty developers with fifty local memories is fifty agents learning the same thing fifty times and telling no one. One graph changes what a team is.
the three dashed seats never receive it, because nobody granted them that graph in the first place.
The parts you can rip out
The parts most products hide — installation, extension, administration — are the parts we handed over. One binary finds the agent tools already on your machine and configures each of them, writes down everything it touched, and puts all of it back on one command.
base installbase uninstallHeadless administration
Everything an admin does — creating teams, inviting people, setting roles, granting scope, wiring in a platform, reading usage — is a call your agent can make on your behalf. The web interface is just one client of that same API, so nothing is locked behind a screen.
Add Priya to the payments graph with write access, invite the new contractor read-only until Friday, and connect our GitHub org.
That is four changes and one invite, and every one of them landed in the append-only log with the actor attached. Nobody had to open a dashboard to do it.
Why it is not slow
Every machine holds a live copy of the graph, so reads happen at disk speed and keep working on a plane. They are never counted against you either, because the meter only moves when something is written or kept.
What it actually knows
Everybody knows it, and nobody is going to fix it. basemode reads the work itself and keeps it next to the reasoning behind it, so the record maintains itself instead of waiting on a volunteer.
one team, one graph, ninety days in
Meaning
Your agent gets the connected picture instead of the closest-looking paragraph, and that is the difference between knowing something and being reminded of something similar.
Most memory is a heap of passages with a similarity search bolted on, so you ask a question and it hands back whichever paragraphs look closest to your words. This stores typed entities with real relationships between them, so a decision is linked to the domain it governs, the project it came out of, the rule it produced and the correction that later retired it. Ask about any one of those and it walks the rest.
Your code
It stops reading twenty files to understand three, and it edits the right one first, the way someone does when they have worked here before.
Every function, struct, import and call relationship is parsed straight from the source and kept current across more than thirty languages. So when someone asks what calls this, or what breaks if I change it, or where this constant actually gets consumed, the answer comes off a map instead of a grep.
The reasoning
Nobody re-litigates a settled question every quarter, and nobody re-breaks the thing that was fixed on purpose.
A decision is stored with the argument behind it and the option that lost, which is exactly the part a changelog line throws away. Six months later the question is not what you chose, it is why the obvious alternative was wrong.
Corrections
The knowledge gets more accurate as it ages, instead of quietly rotting until everyone agrees it is easier to just ask Dave.
When something turns out to be wrong, the correction retires the exact fact it replaces instead of sitting next to it, so every reader only ever sees the live version.
Relevance
Nobody has to maintain a context document, because the right slice shows up on its own as a result of where you already are.
Keywords and file paths route the graph, so working in payments surfaces the payments rules, and opening a migration surfaces whatever went wrong in the last one.
Why it's different
Plenty of tools will remember things for your agents, but every one of them waits to be asked — a store, an index, a search endpoint — and then depends on the model deciding to go there. That decision is the broken part, because an agent does not know what it does not know, so the memory sits unused while the answer comes out confident and wrong.
They hold everything and wait to be searched, so the agent has to reach for it, and know that it should.
DeliveryIt speaks first, at the instant of the action, about the exact thing being touched. There is nothing to call.
What they learn stays per developer, per machine, per session. Whatever one person's agent works out, it stays there.
ReachIt spreads across the team as it is written. Dev A settles something at 10am and Dev B's agent is working from it by 10:01.
They store records that already exist somewhere else — your CRM, your ticketing, your billing.
ContentsIt stores what your team worked out: the reason the auth layer is strange, and the fix that took someone a whole day to find.
Judge an agent by what it produces, not by how well it hunts. One that reads twenty files to get somewhere is diligent, slow, and one missed file away from wrong; one that answers correctly having read nothing is what you actually wanted, and that only happens if something put the right thing in front of it first.
Who sees what
Access is granted over defined slices of the graph, and a query cannot reach past what it was granted. Every write lands in an append-only log with the actor attached, so the honest answer to what changed and who changed it is something you can run rather than something you promise.
Delete on request
Remove a single item and it stops appearing for every reader on every machine, rather than lingering on whichever laptop happened to be offline that day. Retention becomes a policy you set instead of a cleanup project somebody has to run.
Adopting this stops being a compliance argument you have to win before you are allowed to start.
Pricing
Reads are served from the copy on each machine, so they cost nothing and are never counted. You are billed for what gets written and what gets kept, and you know the ceiling before you start.
Free
$0
For solo work and open source. One graph, capped in size, everything else intact.
Start freeTeam
$19per user / month
Up to 50 users. Self-serve from the first minute, and no call with anyone required.
Start freeBusiness
$35per user / month
Single sign-on, read scoping, the audit log and annual terms.
Start freeEnterprise
Talk
Self-hosting, retention control, an SLA, and a security review we expect to sit through.
Talk to usEvery tier reads at disk speed, installs the same way, and uninstalls the same way. The difference between them is how many people are on the graph and what your security team needs written down.
Superpowered by basemode
Nobody changes how they work, and within a week nobody remembers what it was like before.
Free for solo work. $19 per user a month for teams, and reads are never counted.