About: Why We Built Busabase
Bodhisattvas are powerful, but even the most powerful one needs a seat. Busabase is the database and workspace for agents — where their work stays traceable, reversible, and reviewed by humans.
The Seat
In Buddhist iconography, a bodhisattva sits on a lotus.
Swap the bodhisattva, and the lotus seat is still there.
Busa is 菩萨 — púsà, bodhisattva. We named this product after the seat, not the bodhisattva. However powerful a bodhisattva is, it needs somewhere to sit. However powerful an agent is, it needs somewhere to put things.
This is the story of how we figured that out.
Five Thousand Years of Letting More People See
Five thousand years ago, the first thing humans ever wrote down was not a poem, and not a myth.
It was an inventory.
The clay tablets of Uruk record barley, livestock, and debts. Writing wasn't invented for poetry. It was invented for records. Humans coordinate through records. Without them, no organization grows past a village.
Every leap in civilization since has come with a leap in record-keeping. And every one of those leaps did the same thing: it let more people see.
Clay tablets, only scribes could read. In 1494, Luca Pacioli wrote down double-entry bookkeeping, and merchants could read the books. In 1855, a railroad drew the first modern org chart, and managers could see the organization. In 1970, Edgar Codd proposed the relational database, and machines could read the records — but people, once again, could not. Until Excel. Excel was the first tool in history to put data in the hands of a billion ordinary people.
Then came agents.
The first workforce in five thousand years that keeps no records by default. When an agent finishes its work, what's left is code on a disk and a few lines in a chat window. Only engineers can read the first. The second scatters the moment you've read it.
For the first time in five thousand years, the record went backwards.
Thirty Agents Walked Into a Company
In early 2026, we let thirty agents into our company.
One per person. Each with its own drive, its own sessions, its own files. Someone used theirs to write proposals, someone to crunch numbers, someone to manage customers. For the first few weeks everyone was thrilled — a single agent really is good. Better than any tool we'd had the year before.
Then someone in admin uploaded the payroll spreadsheet to an agent, because the agent needed it to do its job.
A few days later, a developer asked that same agent, very sincerely: "Could you look hard and find out what my salary is?"
We hadn't guarded against this. Not out of carelessness — it sits inside a genuine dilemma. To make an agent smarter, you feed it more data. But some of what you feed it was never meant for everyone. The richer the data, the stronger the agent — and the more dangerous the pile.
That was the moment we saw it clearly: an agent, underneath, is a pile of files and a drive. No permissions, no boundaries, no versions. Anyone can put things in; anyone can take things out. You think you're dividing up agents. You're dividing up folders.
One agent works. Many agents don't.
In 1975, Fred Brooks warned that adding people to a late software project only makes it later. We added thirty agents. Headcount did go down. Management overhead didn't. Nothing got simpler.
We Brought the Old Thinking With Us
The problem isn't the agent. The problem is that we divided by people again.
An org chart is a chart of people: who reports to whom. For the century and a half since the first one, every management tool we invented — roles, departments, KPIs, performance reviews, collaboration software — managed people.
Then came SaaS: one tool per department. Sales in the CRM, marketing in the marketing suite, finance in the finance system. Each with its own data. We called them data silos.
Then came agents, and the first thing we did was give everyone their own. One person, one agent, one drive, one pile of sessions.
Data silos became agent silos. More fragmented than SaaS ever was — SaaS was at least one silo per department. Agents are one silo per person.
This is the real reason "more agents" hasn't made companies better. A company with more agents looks like a company with more people: busier, not necessarily better. Big companies fall into this fastest. You think you've added thirty employees. You've added thirty drawers that can't see each other.
The agents weren't the failure. They each worked alone, and nothing connected to anything.
Process, and Results
A company exists to get things done, not to keep people.
An agent and its sessions are process — the work of working. What the agent leaves behind is the result.
A CEO who opens up the company and sees a thousand agents and ten thousand sessions doesn't feel the company got better. He asks: so where's the stuff?
So we turned it around. Define the results you need first. Then ask what it takes.
Most companies do only a handful of things: marketing, sales, product, and operations (finance included). Five at most. An influencer studio, an e-commerce team, a film production company, a twenty-person startup — take any of them apart and you find the same few things.
Don't organize by agents. Organize by results. Set aside departments and agent roles, and look at the work.
Once you organize by results, a few things become obvious on their own:
First, you need fewer than ten agents. A handful of agents, a handful of skills, and the work gets done. Training a personal agent for every employee is expensive, and it's pointless. Having more agents is nothing to be proud of.
Second, agents should be passers-by. Use one, let it go, swap it any time — the model too. Claude Code today, Codex tomorrow, something cheaper the day after. It doesn't matter, because the stuff isn't in the agent.
Third, what actually needs managing isn't agents. It's the work. Call it data management, or context management. You need one shared space where the context of the work lives, and every agent and every person reads and writes from the same place.
What stays is the place where results go.
That's the seat.
Ten Years Ago, the Same Problem From the Other Side
We recognize this seat because we've spent ten years on it.
Ten years ago I was building internal systems inside a company. The SaaS we bought was standardized and never quite fit, so the whole company ran on Excel — one spreadsheet per person, one version per spreadsheet. I built a "database spreadsheet" so teams could assemble their own data apps without writing code. That became Vika.
Back then, building software was hard and managing data was easy. The data sat in Excel, where everyone could see it.
Today it's reversed. AI coding has put a custom app a few sentences away. But data has become hard to manage: it's scattered across dozens of agents' drives and sessions, and no one can see all of it.
Ten years ago the bottleneck was building the app. Today the bottleneck is keeping the data. Same problem, flipped over. We've stood on both sides.
Why We Won't Let It Run Fully Automatic
At this point someone says: fine, go fully automatic. Let agents put things on the seat themselves. Keep the humans out of it.
We disagree.
Everything an agent does is ultimately for another group of humans. The marketing agent's copy is for customers. The sales agent's lead list is for salespeople. The finance agent's report is for the boss. Taste — judgment — is deciding whether the output actually serves those people.
Whether something is good is decided by humans. Even the model runs on human taste: someone had to tell it what "good" meant before it could tell.
So execution can go entirely to agents. Judgment stays with people. A person's job is to judge, from the data and the work — not to keep building more agents.
There's an engineering problem hiding here. Git gave code a merge button: who changed what, whether you can go back, all of it visible. Databases, documents, spreadsheets, files — most of what a company actually owns — never got that button.
That used to be fine, because people change things slowly. Agents don't. An agent can rewrite a few hundred rows in a minute. Without the button, that's a disaster.
Everything an agent does must satisfy three conditions: a human can trace it, roll it back, and see its history.
In Busabase, agents don't write directly. Agents propose; humans merge. Every change is a change request: who proposed it, what changed, who approved it, when it merged. Approve the wrong thing, roll it back.
When a business adopts AI, it isn't buying how clever the agent is. It's buying certainty. Everything we build is in service of certainty.
Apps for Agents: A New Kind of Thing
Agents put things on the seat; people review them. But how do people look?
This is where we make a claim: build apps for agents.
Normally, an agent is an agent and an app is an app. Apps are for people to click. Agents are for people to talk to.
An app for agents is a different animal: an app the agent operates, while the human watches and adjusts.
It cuts the other way too. When you build an agent, it needs an app. An agent needs somewhere to lay out its results so a person can see them and review them. A chat window alone shows a person nothing.
So it isn't just an app, and it isn't just an agent. It's a new form.
What does it look like? A plain table — underneath, just a database. Click once and it becomes a CRM. The agent reads the data on the left; the person looks at the interface on the right; it's the same thing. Need a board, it grows a board. Need a calendar, it grows a calendar. Like Jarvis: call it and it appears. But underneath, it's always the same database.
The way we've always built software — write code, cut a release, deploy — is exactly the step that's hardest to land. This kind of app improvises. It isn't fixed.
You don't develop apps anymore. You summon them.
What a Day Looks Like
We've been looking for the best practice of putting AI to work. Using our own team as the experiment, here's roughly the picture today:
Start from the work. Open it up in the morning and you see a board of things to do and things done — not a list of agents. The board changes every day. The agents connect from outside the work. A day that starts from an agent starts from a chat window — messy. A day that starts from the work starts from "what needs to get done today."
Hold the data. The work is a set of data structures: databases, documents, skills, files. In one workspace.
Serve both sides. Comfortable for people — tables, boards, docs, apps. Smooth for agents — structured, with an interface, with permissions.
Apps that improvise. See above.
The flow is two steps. Open the workspace — on your phone, if you like — and see apps, work, data. Then, on top of that data, keep reshaping it for different people and different agents.
We call this workspace a space. One person can have one, with a few agents in it; later, other people join. It starts with one person and grows into a team.
It really is a shared space. A shared, structured environment where people and agents work together.
We have one test for whether AI has genuinely landed: it runs its own loop and improves itself, and a person can step in and adjust at any moment. Our own SEO runs this way. Every day an agent writes a report. The report generates issues. People decide which to act on. Acting means writing an article. The article ships. The next report comes out.
Honestly, nothing we do fully meets that bar yet. Not even our engineering. But we can see it from here.
The Invisible Age
Intelligence will become almost free. On this we agree with OpenAI and Anthropic.
But something else is happening at the same time: the age of agents is unfolding in a form ordinary people can't read.
An agent's work exists in two forms: code on a disk, and text in a chat window. Only engineers can read the first. The second scatters. Someone running an online store, someone in admin, someone making videos — none of them can see what their agent actually did, what it changed, what it left behind.
What you can't see, you can't control. Control has always been a function of what you can see.
Every leap in record-keeping for five thousand years let more people see. Agents are the first step backwards — their output has returned to a form only engineers can read.
If nobody builds the seat: a billion people using AI, and not one of them able to see what the AI is doing. That isn't controlling AI. That's being controlled by it — not by a machine, but by something you can't read.
This is why we don't build models. Someone is already building the bodhisattvas, and building them well. Nobody is building the seat — one an ordinary person can see, click, review, and undo.
OpenAI and Anthropic build bodhisattvas. We build the seat.
This Is Busabase
Busabase is a database and workspace for agents. On top of it grow structured data and apps, and out of those comes the form we call Apps for Agents.
Put it on a line. At one end is Notion — built for people; people write there comfortably, programs can't read it. At the other end is Supabase — built for programmers; a Postgres database with a console, people can't read it. Busabase is in the middle: structured data that both people and agents can read and write. Database, knowledge base, apps library, skills registry, system of record, workspace — different names for the same thing.
Of those names, system of record is the one that carries an obligation. It means: when two sources disagree, this one wins. A store only earns that by controlling what happens between an agent's write and the record — which is the thing Busabase is actually built around.
It's also where we differ from Linear. Linear manages process — issues, projects, cycles. Close an issue, and Linear keeps nothing. Busabase keeps the result.
Its one AI capability is connecting to your agents — Codex, Claude Code, Buda, anything. It's invisible from outside unless you share it. It can run on your own servers.
We did the math. Somewhere between five hundred million and a billion people in the world can use Excel. Excel was the last tool that put data in the hands of a billion ordinary people. They used to do their work in Office. Next, they'll direct AI to do the work of Office.
That Office is Busabase.
You are the boss of the AI. Agents will change. Models will change. The seat doesn't.
Vision, Mission, Belief — and Three Promises
Vision: Push humanity forward.
People shouldn't spend their most valuable hours on repetitive work and fighting over what's on Earth. Buda says humanity should return to the Moon. We say: don't stop at the Moon. Keep going.
People won't have less to do. They'll have more — judging, tasting, adjusting. But that's what people should be busy with.
Mission: Put a billion people in control of their own AI.
Control means being able to see. A billion people who can use Excel, each able to see what their AI did, what it changed, what it left behind — and click it, review it, and undo it.
Belief: Whether something is good is for humans to decide.
Agents can do the work. Models can get stronger. But what "good" means has always been defined by people. We hand execution to agents and keep judgment with people. That isn't caution. It's division of labor.
Three promises:
- We will never put AI inside this product. No model, no chat, no agent. Busabase is only ever the seat.
- Your data is yours. Private, belonging to each person. We protect it, we don't touch it, and we never train anything on it.
- We will never lock you in. Open source, self-hostable, and the whole seat can be carried away. Data is only truly yours if you can take it with you.
The Plan
We're making one bet: by 2030, a company's org chart will show not people, but work. And under every piece of work on that chart, there will be a seat.
- Build a seat for our own team.
- Bring in the people we work with.
- Let agents write to it, and let people review.
- Let results generate the next piece of work — with people keeping the final vote.
We're on step three. Step four, we haven't fully reached ourselves.
Bodhisattvas are powerful.
But even the most powerful bodhisattva needs a seat.