An AI-native company is three layers

Every company I talk to says it is AI-native. Almost none of them can say what would have to be true for it to be one. The word has come to mean we bought the licences and people are faster. That is a real gain, and it is not what we mean.

Here is what we mean by an AI-native company. It is one where agents work alongside people and carry the work forward like employees who live inside the organization. Agents that own something, with a person who answers for each one.

That takes three layers, and they stack.

Skip one and the layers above it do not hold. Most of what gets called AI-native stops at the second one, and the second one has a ceiling.

Layer 1: the memory

One shared, living memory of the company. The customers and the people. The calls, the mail, the Slack threads. The decisions we took and the outcomes we got. The themes we care about, and the rules that say who we are: how we write, what we sell, what we never put in writing.

This is the layer that turns a generic model into our model. Nothing above it works without it, because the quality of an agent is the quality of its context. The industry calls that discipline context engineering. Inside a company it is mostly a writing problem.

Ours is a git repository. Markdown files, one per thing, linked to each other.

• Canon. The constitution. Who we are, how we sell, how we write, what we never write down. When two files disagree, canon says which one wins.
• People and companies. One file each, linked to the deals and the calls they appear in.
• Signals. Every call, every mail thread, every public Slack channel, written down the day it happens.
• Themes. The arguments we care about, with the evidence attached.
• Skills. Not knowledge, procedure: how a specific job gets done here, written so it comes out the same way twice.

What it asks of us is not technical. Write it down once, keep it current, and never let knowledge sit in someone’s head or in a call nobody listens to again. That is a cultural cost, paid daily, and it is the whole price of the layer.

The part that surprised me is that prose is not enough. A rule an agent can talk itself out of is a rule that gets broken on the run nobody is watching, so the things that must never be written down are enforced by a hook at write time, not by a paragraph asking nicely. Write the rule, then make it impossible to skip.

The bar for this layer: any agent, in any tool, answers a question about a customer or a theme without anyone pasting context into the prompt.

Layer 2: the harness, and we do not build it

Memory does nothing on its own. Something has to read it and work on top of it. That is the harness, and we decided early that ours would not be ours.

Claude Code, Codex, Cursor. They improve every few weeks, faster than a team our size could move, and anything we built in that space would not be worth running by Christmas. So we rent the middle and we build the two ends. The memory is ours and nobody else can have it. The employees on top are the company. The layer in between is a tool, and tools get bought.

We use it two ways.

Chat. You ask, and the answer already carries the company. No briefing, no context dump.

Routines. Work that runs on a schedule with nobody starting it. The call recaps, the Slack and email signals, the weekly sales report, the leadership recap, the morning meeting brief.

The gain here is time. Same job, same owner, fewer hours, fewer mistakes, because the same steps run the same way every time.

The bar for this layer: every person can name work that has stopped being manual for good.

Layer 3: virtual employees

This is the layer that decides whether the phrase means anything, and it is the one worth spending the rest of this post on.

The ceiling at layer 2 is our own time. Chats and routines make us faster, but the work still starts when a person sits down and asks. At layer 3 the work starts without anybody asking, because somebody owns it, and that somebody is not a person.

What counts as a virtual employee

An agent that syncs Stripe is not a virtual employee. It is a routine with a good name. The line is ownership: it becomes an employee when it takes over a function, or a piece of a department, and somebody’s job becomes making it better.

Five things have to be true, and if one of them is missing we have built a routine and dressed it up.

• It owns a function, not a task. Assistant engineering, bookkeeping, product design, outbound on one market. A job you could put on an org chart.
• It gets hired. Handing a function to an agent is a leadership decision, taken the way we take it for a person. Not self-service, not whoever felt like automating something on a Friday.
• We map the department, not the tasks. If getting started means mapping task by task, it does not scale and we should not begin. We start from the org chart, not the to-do list.
• It is manageable. I have to be able to give feedback and watch it grow. If I repeat the same correction twice, or go back into the chat and do it myself, I am the babysitter and I have managed nothing.
• It works on our values and is judged on them. Own the Outcome, Feedback First, Craft, Fast by Default, Low Ego, Customer First. The same six we judge ourselves on, because an agent that ships fast and burns a customer’s trust has failed the same way a person would have.

Everything an employee needs

If it is an employee, it needs what an employee needs. All of it, not the convenient half. Managing an AI agent turns out not to be a new discipline. It is the old one, pointed at something that is not a person.

Four of those eight carry the whole argument.

The cost. An agent has a bill: tokens and infrastructure, over a year, sitting next to the cost of the work it covers. That comparison is the hiring decision, and it is the reason this is a business question and not an engineering one.

The manager. One person, by name. Not a team, not a committee, not the AI did it. You always own the outcome, even when the agent produced it.

The feedback. This is where the three layers close into a loop. A correction typed into a chat window dies with the session. A correction written back into the memory is there for every agent, on every run, forever. So the manager’s job is not to fix the output. It is to fix the thing that produced the output, once, so the same correction is never needed again.

The evaluation. We already know how to do this, because we do it for customers every day. An agent’s work gets scored against hand-worked examples and a correctness threshold, not against a feeling, and the score gets rerun on every change. The discipline a Retail Engineer brings to a customer’s catalog is the same discipline we owe our own work.

Autonomy is earned, the same way

Draft, shadow, promoted.

Draft. It proposes, a person ships. Everything it produces is a suggestion.

Shadow. It does the whole job, and a person reads every output before it leaves the building.

Promoted. It ships, and the person samples.

Nobody arrives promoted, and nothing gets promoted on enthusiasm. It moves up when the score says it can, and it moves back down when the score says it cannot. Which is how it works for people too, on the honest teams.

What one looks like

Take outbound on the UK market. It finds the leads, puts them in HubSpot, writes on LinkedIn, writes the mail, picks up the phone, books the meeting, moves the pipeline. It has a cost per year. It reports to one person, who manages it the way they manage anyone else on their team: reads the output, corrects it, tightens the rules, and answers for the number at the end of the quarter.

That is the shape. Anything short of it is layer 2 with better marketing.

What an AI-native company changes for the people inside it

Our job changes. We stop producing the work and start making the agents that produce it better. Read the output, correct it, feed it what it missed, tighten the rules so the same correction is never needed twice.

What that does in practice is not that anybody works less. Everybody gets more done, because most work now arrives started rather than needing to be started. Part of the week goes into improving a skill instead of performing it, and that compounds: the task ends, the improvement stays. And we argue from first principles far more than we used to. When execution stops being the expensive part, whether a thing should be done this way at all becomes a question worth reopening, and there is finally time to reopen it.

That is a harder job, not an easier one. It is the difference between being a good executor and being a good manager, applied to work that used to be entirely yours. The people who take to it are not the ones who type fastest. They are the ones who can say precisely what good looks like, and who go and write it down.

The part nobody can sell you

The models are available to everybody, on the same terms, on the same day. The harness is a purchase. Neither of those is an advantage, and building a company around either one is building on somebody else’s roadmap.

What cannot be bought is the memory: our customers, our decisions, our rules, our way of writing, kept current by people who care whether it is right. That is the layer we started from, and it is the layer that makes an agent ours rather than generic. It is also the layer our customers buy, pointed at a catalog instead of a company.

An AI-native company is one where the org chart has agents on it, and every one of them has a manager who answers for it. Everything else is software.