og.rsts.dev
← writing

The Model Is Not the Employee

Listen 0:00 / 0:00

Models can do the work. What they cannot do is answer to anyone. The Agentic OS is a thin operating layer between an agent runtime and a business: agents draft, people approve, every step lands in a record nobody can quietly edit, and the same six primitives fit a two-person shop and a regulated enterprise.

The Model Is Not the Employee
Contents

An agent is not an employee until someone can supervise it.

Every demo I see this year proves the same thing: the model can do the work. It can answer the phone, draft the email, update the website, summarize the week. Then a business owner asks the question that ends the demo. Who approved that?

Capability Was Never the Bottleneck

The agent runtimes are good now. Open-source ones give you tools, memory, schedules, chat channels and model routing out of the box. Put one on a small server and it will happily work all night.

That is the problem. A runtime is a process. An employee is a process plus everything a business wraps around a person it trusts with real work: a manager who signs off, a record of what happened, a badge that opens some doors and not others, a handbook that changes through review, and a way to say “stop” that actually stops.

Nobody hires a brilliant stranger and hands them the company card on day one. Yet that is the default shape of most agent deployments: full capability, no supervision layer, and a log file nobody reads.

Where the Idea Came From

The Agentic OS is the name for that missing layer. I want to be precise about credit here. The core ideas were proposed by the team at RSTS AI (opens in new tab), who build managed AI employees for small service businesses and live with this problem every day. My part was the architect’s part: pushing on every idea until it held up, turning it into something a host could run, and breaking it on purpose.

The shape came out of interactive working sessions, not a whiteboard. Someone proposed a rule. We built it with agents in the loop, ran it against a real deployment, found where it leaked, and tightened it. Then again. That loop is why the result reads less like a framework and more like a set of scars.

What follows is the layer as I now understand it, abstracted from any one runtime or vendor.

Six Primitives Between the Agent and the Business

1. Agents draft, people approve

This is the rule the whole layer hangs from. An agent never takes a consequential action directly. It files a proposal: send this email, publish this page, change this rule, switch to the backup model provider. A person whose role covers that kind of action decides, either on a web console or with one tap on a card in the chat they already use.

The refusal path matters as much as the approval. If someone without the right scope taps “approve”, the layer refuses, names the roles that can decide, and records the attempt. OWASP lists excessive agency (opens in new tab) among the top risks for LLM applications and recommends human approval for high-impact actions. The Agentic OS treats that recommendation as architecture, not advice.

2. A record nobody can quietly edit

Every tool call, every block, every decision and every publish is appended to an audit trail where each entry carries a hash of the one before it. Edit or delete a row and the chain breaks visibly. The two halves of the system, written in two different languages, compute the hash byte for byte the same way, so there is one chain no matter which side wrote the entry.

A business owner will never ask for a hash chain. They will ask “did the agent send that?” six weeks later. The chain is how you answer with a fact instead of a feeling.

3. An off switch that means off

One control pauses every agent; another pauses a single one. While paused, incoming work is held, not dropped, and it resumes in order when the pause clears. Bookkeeping, like recording a decision someone already made, keeps flowing. Publishing does not.

It sounds trivial. It is not. An off switch that half-works is worse than none, because people stop trusting it right when they need it.

4. A handbook that changes through review

Every business runs on knowledge nobody wrote down: prices, policies, how you talk to customers, what you never promise. The layer keeps that knowledge as plain pages in version control, which the team calls the Brain. Agents read it to stay grounded. When an agent learns something new, from a call or a document someone dropped in, it proposes an edit. A person reviews the diff, publishes it, and can roll it back later.

The agent gets to suggest how the company works. It never gets to decide.

5. A badge for every person

Access is not one setting per agent. It is per person: which agents you may talk to, and which tools those agents may use on your behalf. The owner’s request can trigger a payment-adjacent tool; a part-time helper’s request to the same agent cannot. Every allow of a sensitive tool and every denial is recorded with the person as the actor.

When the layer cannot tell who is asking, it fails closed. An unknown session gets read-only tools, and if the access check itself errors, the call is blocked. Deny by default is boring. Boring is the goal.

6. Capabilities as packs on a stable core

The core is what every business needs: people and roles, approvals, the audit trail, the off switch, the Brain, cost and model administration. Everything specific to a business is a pack: a phone line, a website pipeline, a content calendar, a reporting job. A pack registers its own screens, tools, approval types and events. It never edits the core.

That separation is what keeps the layer honest as it grows. The fifth business does not fork the platform. It adds a pack.

Three stacked layers. Bottom. Full description below.

Image description

Three stacked layers. Bottom: Model + Agent Runtime. Middle: Agentic OS, with six tiles: Agents Draft, People Approve; Tamper-Evident Audit; Off Switch; Governed Brain; Per-Person Badges; Capability Packs. Top: Small, Mid-Size and Enterprise, all connecting down into the Agentic OS

Two Habits That Came From Getting Burned

Two smaller ideas came straight out of the working sessions, and I now consider them part of the layer.

Live systems are observe only. A phone line that customers call is watched, never touched. The layer reads its records and archives every call, but never restarts it, never links its guardrails into it and never lets a deploy go near it. Deploys in general never restart a running agent. Restarts are an operator’s decision, made in a quiet window.

Cost is a decision, not an accident. When the primary model provider hits its usage limit, the agent does not silently fail over to a more expensive backup. The layer files an approval: switch providers until the limit resets, capped at a day. A person grants it, the grant expires on its own, and anyone who can see the console can revoke it early. Savings work the same way in reverse: a built-in cost review proposes cheaper settings, and a person applies them through the same approval flow.

The Same Layer at Three Sizes

The part I find most compelling is that nothing above changes with scale. What changes is who holds the roles.

Small business. One owner, one or two agents, maybe a part-timer. The owner approves from a phone, between customers, with one tap. The Brain is the owner’s own handbook, finally written down. Packs cover the phone, the website and the posts. The value is not the audit trail. It is being able to leave an agent working and go home.

Mid-size organization. Several approvers with different scopes: marketing approves content, operations approves customer emails, finance approves anything with a dollar sign. Budgets and provider policy become real. Per-person access matters because twenty people talk to the same agents. The Brain becomes the place where tribal knowledge stops depending on who has been there longest.

Enterprise. Here the primitives map one to one onto controls every large institution already runs, which is the point. Approvals are segregation of duties. The hash-chained trail is evidence an auditor can verify. Per-person access is identity and least privilege, extended to the agent acting on someone’s behalf. Brain review is change management for knowledge. The off switch is the incident runbook’s first line. Frameworks like the NIST AI Risk Management Framework (opens in new tab) ask organizations to govern, map, measure and manage AI risk. This layer is one concrete shape for the “govern” and “manage” parts at the level where agents touch real systems.

Two Goods, One Layer

I have argued in many posts that enterprise AI lives between two legitimate poles, and this layer sits right on the line between them.

The experience side is real. People want the work done where they already are, in the chat they already use, without opening a ticket. Approving an email with a thumb on a phone is a better experience than any portal. Agents that resolve the routine work while a person keeps the final word make small teams feel larger.

The control side is just as real. An institution must know who acted, on whose behalf, with which data, through which provider, and be able to prove it later. A tool that answers “trust me” to any of those questions deserves a hard no.

The resolution is the same one I keep arriving at. The control plane is what lets you say yes to the experience. Because every action is a proposal, every decision is recorded and every person has a badge, the business can let agents into the chat channel and the phone line instead of keeping them in a sandbox forever.

What I Have Not Solved

Approval only works if the person approving is actually thinking. In Whose Call Was It? I wrote about how experts follow an agent’s lean most of the time and still believe the decision was theirs. One-tap approvals make that worse, not better. The layer records who approved; it cannot record whether they read. Better cards, sampling reviews and friction on high-impact kinds help. None of them solve it.

The boundaries are also softer than they look on a diagram. The privileged helpers are scoped and paranoid, but on a host where the runtime’s user already has broad admin rights, they are defense in depth, not a wall. Remove those rights, or the scoping is theater.

And it is young. It runs on a handful of small deployments and a demo, not on a fleet. I would not hand it to an enterprise today without the identity integration, the evidence export and the independent review that enterprise deserves. The concepts transfer. The code still has to earn its way up.

Where This Lands

The industry spent two years asking how smart the model is. The more useful question for anyone running a business is how supervisable the agent is. Capability without supervision is a liability with a nice demo.

What I like about the Agentic OS is that it does not try to make the agent smarter. It makes the agent accountable: a manager, a record, a badge, a handbook and an off switch. Those are the oldest ideas in how organizations trust people, applied to something that is not a person.

Next I want to see the same layer run at mid-size scale, with several approvers and real budgets, and measure where approval fatigue starts. When I have numbers, I will write them up.

Prefer to watch? The video version is on YouTube (opens in new tab).

If this resonated, read A Second Brain Needs a Body: that post asked for permissions, an immune system and a way to serve more than one person, and this layer is my best answer so far. For who the RSTS AI team is, start with The Best Decision My Daughter Made Was Betting on Herself.

Find me on X @orestesgarcia (opens in new tab) or LinkedIn (opens in new tab).