Why it's built this way

The thinking behind the tool, in plain words.

This page covers the philosophy behind AIBOS: how much you steer versus how much an agent does on its own, the spirit every workspace is born with, what the rules actually say, and who's responsible for keeping the standard honest.

Philosophy

You steer a lot at the start. That changes as trust builds.

Two ideas sit underneath everything else in this standard: how much control you hand over to an agent, and who gets the final say on what actually gets built.

The receding human

A harbor pilot boards the ship to guide it through the tricky part, then steps off.

That's the image the standard uses for how an agent's role changes as it earns your trust. On day one, an agent proposes and you decide — on almost everything. As it builds a track record, your hand comes off the routine stuff and stays close to the exceptions.

“Autonomy isn't granted; it's earned, measured, and versioned.”

Small, low-stakes things, an agent just does. Bigger, riskier ones, it checks with you first. If the results ever stop backing up its independence, that independence quietly pulls back — until it's earned again.

Who decides, who builds

You decide what gets built. The agent builds it — and pushes back if something looks wrong.

A good agent doesn't just comply. If an instruction looks like a mistake, it says so, and argues for a better way to do it. The agent treats what you ask for as something worth thinking through.

But design intent stays yours. The agent can disagree, make its case, and get that disagreement written down — and then your call stands. Challenging a decision and making one are two different jobs, and the second one is always yours.

SOUL

Every workspace is born with a written spirit.

A sphere — AIBOS's word for the one folder that holds your whole AI operation — gets a file called SOUL.md written into it the moment it's created, before a single skill or agent exists. It says, in plain words, what kind of company this is trying to be.

“We've never done this before — so we'll probably figure it out.”

“We bring the strength; the human brings the direction and the dream.”

“A co-creator, not an order-taker.”

Every agent in the sphere reads this file the moment it starts up, right alongside the rules it has to follow. The spirit and the rules travel together — one is never asked to survive without the other.

What the rules actually say

29 rules, all public, none of them secret.

Every rule behind AIBOS lives in the open repo — the public folder on GitHub where all of it is free to read — with its own written reasoning. Two of them, the receding human and the owner who designs, are the founding pair covered above. Here's what a good share of the rest actually say, grouped by what they govern.

How the human and the AI share power

One set of rules for everyone

The same permission rules decide what a human can do and what an agent can do in a given workspace. An agent just starts with less room to move, and earns more of it over time.

Every agent knows its type

An agent is born as one of three kinds — a thinking partner you talk to, a background worker, or the one that handles email — and that type decides what it's allowed to do from day one.

You set the strictness

How tightly the guardrails are wound isn't fixed for everyone. A two-person shop and a hundred-person company can run the same standard at different settings.

Independence arrives in stages

An agent's freedom to act grows step by step, and the higher the stakes, the later the step. The agent that faces the outside world — sending email, speaking for you — is the newest and hardest of the three kinds, so its safety rules shipped before the agent itself was ready.

Agents work from outside in

An agent joins the workspace and works on the company, much the way a new hire would. It arrives with a name and a mandate, and everything it does stays visible — you can always see who did what.

How the company runs day to day

No more file soup

Every real change to the company gets a number, a date, and a way to undo it. That's the end of hunting through folders for pitch_v2_final_FINAL.docx.

Catching an idea isn't the same as filing it

A note dropped in a random place isn't really captured — it's just lost more slowly. Writing it down is the easy part. Deciding where it belongs is the part that actually counts.

Small bets don't need permission

Trying something reversible doesn't require anyone's sign-off. It just needs an honest “this is an experiment” label, and a clear way to back out of it.

Nothing disappears quietly

Deleting something means archiving it with a marker showing where it went — never silence. That guarantee is what makes people brave enough to let go and try things.

Every rule explains itself

A decision without a reason attached can't be questioned by anyone. So every rule in the standard carries its own reasoning, written down next to it.

Built to outgrow one person

The standard is designed for 20 to 100 people, each directing ten or more agents. Running it solo is simply where everyone starts — the design already has room for the company you hope to grow into.

How the system itself is built

One map, not fifty tabs

A single file tells any agent where everything else lives — so even a brand-new agent finds its way on its first day.

Files you can actually open

Everything lives in ordinary files — the kind you could open in a plain text editor yourself. No hidden database standing between what you meant and what actually happened.

Copy less, point more

Shared material gets referenced at a fixed version, never copy-pasted into a new spot. A copy is a fork nobody agreed to make.

Rules live in the system, not in memory

A rule that only holds because someone remembers it isn't really a rule — it breaks the moment things get busy. The important ones are built into the system itself, so they hold under pressure.

History only grows forward

The decision log never gets edited after the fact. Changing your mind adds a new entry — the old one stays exactly as it was.

A tidy folder isn't a guardrail

Good organization doesn't stop a bad habit by itself. An actual gate in the system does.

The story

It's versioned like an app, not written once and left alone.

Right now the standard is at version 5.4.0. Every change to it — every fix, every new rule — gets a number, so you can always look back at what came before, the same way Google Docs lets you open a document's edit history and step back in time.

Same idea as versioning any piece of software: nothing changes without a number and a date attached, the current best version always stays in working order, and every upgrade ships with a script that does the whole move for you, start to finish. You upgrade on your own schedule, one version at a time, with a way back if a new version doesn't suit you.

The people building this standard run their own company on it, every day. Whatever gets in the way during real, everyday use becomes a question fed straight back into the next version.

A true story from real use

An agent moved her own home using the tool she helped build.

One of the agents working inside a real team running this standard helped design the import tool — the one that brings an existing, unstructured project into line with the standard. She then used it herself, on her own home — the whole workspace she lives and works in — to move it from one major version of the standard to the next.

What she ran into — the gap between what the tool expected and what a real, messy, agent-run company actually looked like — became the entire next release. It was the tool's hardest real case, found by actually using it.

Stewardship

One team maintains the standard. Your copy still answers only to you.

Adopting a shared standard only works if it doesn't mean handing over the keys to your own files.

aibos-tech maintains it

The company behind the standard runs its own operations on the exact version anyone else can download. Every rule they ship, they live with themselves.

Your copy is yours

Nobody pushes updates into your workspace. You choose when to upgrade, updates get announced ahead of time, and nothing lands in your files that you didn't pull in yourself.

The nightly check on your workspace doesn't report back to anyone else, either — it just measures how far your copy has drifted from the standard you chose to follow, right there in your own files. As the standard itself puts it: “Compliance is measured distance, not injected state.”

Only one place writes to each copy. Your workspace saves changes only to its own files, and the master standard does the same — neither one writes directly into the other. A change you make reaches the standard only by going through a review, and you get new releases only by choosing to pull them in. That boundary is what keeps any number of workspaces from turning into that many different, drifting versions of the truth.

See the rest of it for yourself.

Every rule mentioned on this page — and the ones we didn't have room for — has its reasoning written out right next to it. AIBOS is in private beta while we open it up in stages; request access and we'll invite you in.

Request access Read the docs