Operant is the delegation layer for software delivery: a deterministic harness that runs the work end to end, proves every change with evidence, and chases each person for the one call only they can make — through their own browser and devices, not a sealed-off cloud.
Today, a person drives the model. You open a session, you remember where each thread left off, you nudge it forward — and when you look away, it stalls. Operant flips that arrangement. It runs many loopsA single ongoing task the harness is working through — a feature, a fix, a deploy — with its own state and its own next step. A person typically has several open at once. at once, holds one durable source of truth for where everything stands, proves each change before it reaches you, and actively chases the right person for the one decision only they can make.
Delegation here is not a smarter model — it is a contract. The harness commits to a process, shows its work, and respects your attention. Because it operates through the user's real browser and devices, it can do the messy, authenticated, real-world work that stops other agents cold. For a software delivery team whose engineersEngineers embedded within a client team to build alongside them, staying on the delivery firm's contract. Each typically carries two or three client engagements at once. each carry two or three engagements at once — that is the difference between an assistant you babysit and a teammate that keeps the whole portfolio moving.
Every capable coding agent today shares one assumption: a human sits at the centre, holding the plan in their head and pushing each thread forward. That works for one task. It collapses across six. The moment your attention moves, the threads you left mid-flight go quiet and wait — politely, indefinitely — for you to come back and notice.
Operant moves the centre of gravity. You set the plan, the people, and the rules once. After that, the harness owns the choreography: it knows which loops are running, which are blocked, and who holds the key to each one — and it goes and gets them. The work no longer waits on your memory. It waits on a system whose entire job is to not let it wait.
4:00 pm · six threads openYou kick off six loops across three clients, then drop into a call. A standard agent fires one desktop ping; you miss it; an hour later nothing has moved. Operant treats "waiting on a human" as an active state, not a dead end — it keeps reaching out until the block is cleared.
Underneath the manners is machinery: decision gatesPoints in the pipeline where the harness needs a human call before it proceeds. Each gate routes across channels and escalates on a timer, so a missed message is retried and re-routed rather than silently dropped. with multi-channel routing and timeout escalation. A single ignored notification is not coordination; persistence is.
Monday · a brand-new windowYou open a fresh session and type four words: read status, then continue. It picks up exactly where Friday left off — every plan, every dependency, every "next."
The harness runs on a deterministic state machineA hardcoded process engine with defined states and transitions, written in ordinary code — not improvised by the model. Strip the AI out and a complete, file-based, crash-resumable delivery pipeline still remains. with file-based, crash-resumable state. Coordination lives in a durable, governed record with explicit "next" markers — not trapped inside one conversation that dies when the window closes.
The thing you actually approveYou don't get "I think it's done." You get the change, the evidence it works — a passing check, a screenshot of the working screen — and a one-tap approval. What reaches you is already verified.
Delivery is run by a small team of scoped agents — a builder, a maintainer, and a verifierA dedicated checking role (and visual auditors) that inspects the work and produces evidence before anything is surfaced for sign-off — so the human reviews proof, not promises. that audits the result and attaches the evidence. For a software delivery team, that verified-by-default posture is the quality bar travelling with every engagement.
Two clients · two rulebooksClient A lets the agent push freely to a sandbox branch. Client B requires a human to approve every edit. Both run at once, and neither can touch the other's environment, credentials, or repo.
Each session is independently configured: its own permissions, branch rules, git hooksAutomated checks that run at points in a code workflow — before a commit, before a push — to enforce rules like tests passing. Operant uses them to make a project's policy self-enforcing., and guardrails, packaged so the rules travel with the project and enforce themselves.
The contract clauseA client forbids source and credentials from leaving managed devices. A cloud-hosted agent is a non-starter before the first line of code. Operant runs the context on the laptop the engineer already uses.
Context, credentials and profiles live on the user's own machine, with a common layer shared cleanly between local and cloud execution. The result is a low-egressAn architecture where sensitive data stays on the user's device and as little as possible crosses the network boundary — easier to reconcile with strict client security and data-residency terms. posture a hosted sandbox can't easily meet.
Taught once, known everywhereOne engineer walks the harness through a client's quirky deploy ritual on Tuesday. By Thursday, every seat at the firm performs it the same way — without being told.
Hard-won procedure gets codifiedThe flywheel: a workaround proven once becomes reusable procedure and accumulated delivery memory, shared across seats — so the system gets better the more the team uses it, a moat that grows with adoption. into shared memory. Adoption becomes a flywheel rather than a flat cost.
Ask any standard agent to log into a client dashboard as you, and you hit a wall. It spins up a throwaway headless browserA browser with no visible window, driven by automation. Convenient for machines, but invisible to the operator and easy for websites to detect and block.MDN · Headless browser ↗ you can't see; the site flags its user agentA signature every browser sends identifying what it is. Automation tools send a tell-tale one, and many sites block it outright.MDN · User-Agent ↗ as a bot; a CAPTCHAThe "prove you're human" challenge — designed specifically to stop the kind of automated browser most agents drive. appears; and even when it doesn't, the agent often refuses outright. The real, authenticated web stays out of reach.
Operant takes a different route. Instead of driving a foreign browser, it connects over a debug portA control channel a real Chrome can expose (the Chrome DevTools Protocol) that lets a program operate the actual browser you already use — your windows, your logged-in sessions — rather than a separate automated one.Chrome DevTools Protocol ↗ to the everyday Chrome the engineer already uses — their profiles, their live sessions — through a purpose-built connectorA small adapter (built on the Model Context Protocol) that gives the harness a controlled, well-defined way to use the real browser — here, the team's own "mybrowser" integration.Model Context Protocol ↗ we call mybrowser. To the website, it is simply a person at their own machine. And when a moment genuinely needs a human — a card check, a one-time login — the operator sees the window and steps in, because the work is happening in a browser they can actually watch.
No tell-tale automation signature, no bot wall, no CAPTCHA dead-end. Authenticated, profile-bound sites that block every other agent simply work.
Because the real browser is visible, live authentication and edge cases become a quick hand-off — not a hard stop that kills the run.
The fair question deserves a direct answer: why won't a frontier lab simply absorb this, or any team clone it? Because the value comes from deep, non-AI infrastructure the model operates within — three layers of it that are product engineering, not prompting.
A hardcoded, deterministic pipeline with file-based state, multi-channel gates, timeout escalation and crash-resumable recovery. Remove the AI and a complete delivery process remains.
Operating a user's real machine and browser, on their devices, as them. It can't be retrofitted onto a cloud IDE or a chat window — it has to be the architecture from the ground up.
Scoped agents that build, maintain and verify, with handoff protocols and evidence — plus delivery memory that compounds per seat. The model improving only makes this layer stronger.
And for the specific ground a software delivery team occupies, two more reasons compound: gluing an agent tightly to a team's own fleet of laptops, profiles and client quirks is high-touch, low-margin work a platform vendor is structurally disinclined to do — while operating a user's own logged-in browser sits in a grey zone a giant is reluctant to officially bless. A focused company can own both, deliberately and responsibly.
A working pipeline plus an assembled, paying audience is the foundation you would be building on — not a promise of one.
Delivery engineers don't run one project at a time — most carry two or three concurrently, and the cost of that context-switching is exactly what a coordinator is built to absorb. The harness keeps every thread alive while attention moves, which is where the compounding gain comes from.
We'll set the precise figure together against your own baselines during the pilot — but even a conservative reduction in idle, blocked, and re-orientation time, multiplied across a multi-project workload and a full roster, clears a per-seat price comfortably.
The honest concern is configuration at scale: a delivery portfolio is wildly diverse, and no tool works identically across all of them untouched. Our answer is to refuse to boil the ocean and instead win the fat headsThe handful of use cases that account for the bulk of real work — as opposed to the long tail of rare, bespoke ones. Cover the fat heads well and you cover most projects without custom engineering each time. — the few capabilities almost every project actually needs.
Effectively every company ships a website and a web product. One generic, workspace-aware integration of the real browser — contextualised per project, no per-site engineering — covers the dominant case on day one.
Most have a mobile app. A second integration drives an Android or iOS simulator, or a real device, the same standardised way — so mobile flows are in scope without a bespoke rig per project.
Start from the thin model wrapper — the model supplies the compute and intelligence — and bake in two or three standard connectors that handle browser and device generically. What remains per project is configuration, not engineering: declaring permissions, profiles and rules, not building new plumbing. That is the difference between a tool that scales across a portfolio and one that needs a specialist for every engagement.
We don't want to drop a tool over the wall and hope. We want a small, real engagement: a handful of seats, two or three live delivery tracks, and a short window to tune the harness against your actual portfolio — the genuine browser flows, the genuine client rules. We learn your nooks; you get engineers who stop babysitting agents and start shipping through them.
The destination isn't a faster delivery team. It's one where human attention is spent on judgment — and everything downstream of a decision simply happens.