Autonomous operation

What is autonomous operation?

Autonomous operation is how much of a company's work runs without a person approving each step. Its degrees run from No AI to AI as an Agent. The Machine, Orbyt Labs' agent organization, runs in Collaborative mode today: its agents work on their own, with a person in the loop on decisions.

The Collective's own answer to what runs without a human lists what runs unattended today, then names the goal.

As of September 2026: the scheduled runs of the seats, each seat one agent with a written charter; the guards; the daily pulse; the second reads of the evaluator, a script with no AI in it; and the promotion ladder's checks all run unattended, and the evaluator or the ladder can halt a seat on its own.

Fully unattended operation, where every failure is caught by the machine itself, is the research goal, not the current state.

Orbyt Collective FAQ, dated September 2026, the first and last sentences of one answer

Collaborative is how the Machine runs today: it works on its own, with a person in the loop on its decisions.The mode switch on the Features page

Read against that framework, Collaborative mode sits between AI as a Collaborator and AI as an Expert: the agents drive the work, and a person guides it and makes every call the Machine is not written to make. Autonomous mode, still being built, is defined in the Collective's glossary as the Machine deciding and fixing things on its own, with nobody in the loop on its decisions, which points toward what the framework calls AI as an Agent. Money, public claims, anything irreversible and the gates stay the founder's in either mode, and this page does not place the mode at that degree. The paper marks its own example at that level as not yet unlocked, and its table notes that the right level "need not be the maximum achievable". Reading the two modes against these degrees is this page's own mapping. The promotion ladder is not a set of levels and does not compute that mapping: it is the staged rollout that turns the organization's own parts on, in order, on committed evidence, and it never grants authority.

Three names recur below. A seat is one of the Machine's standing roles, each with a written charter, run on a schedule; most are run by an agent. The FAQ's "each seat one agent" has one exception, the Inspector General, described under the path. The handoff loop is a script on the founder's Mac that starts one agent session after another, each picking up the handoff the last one wrote. The daily repair run, called pulse-fix, is another agent on that Mac: it reads the daily pulse, the organization's own daily health report, and tries to fix what is red.

Key findings

• As of Nov 6, 2026, the Machine sits at stage 2 of a ladder running 0 to 4, with 1 of the stage's 3 criteria met.
• From Sep 22, 2026 to Sep 26, 2026, UTC days, the handoff loop ran at least 139 iterations by its log (138 in the run files that could be read) in 26 stretches; 9 of those stretches ended with a person.
• Since Jul 21, 2026, the seats completed 181 of 198 recorded runs, 91.4 percent, on a record the organization grades itself.
• As of Nov 3, 2026, the daily repair run has landed 0 changes directly on main and opened 3 pull requests, 1 merged by the founder.

Where is the Machine on the road?

The promotion ladder holds the Machine at stage 2, of stages 0 to 4. It has met 1 of the stage's 3 criteria and will not promote while any is unmet. Promotions are not paused, and the ladder last ran on Nov 6, 2026.

Counted November 6, 2026

The autonomy policy file holds the rules that would let the Machine take a corrective step on its own, such as pausing a seat, each at one of three levels: observe, propose or act. A rule at observe logs what it would do and writes nothing, and a rule moves up only by a logged decision. It holds 1 rule, 1 at observe, so it does not act on its own yet.

Phase One is the first stage of the Collective's build plan, one row for each piece of work: a row is landed when its code is in, and closed when its acceptance has passed on main. It has 21 of 74 rows closed, 2 landed, 10 building and 41 open. The repair seat, a separate worker built to take one finding at a time and fix it behind the landing gate, the check that decides whether a change may land on main, become a pull request or be refused, is one of the landed rows, not a closed one: its code is in, and its first attended walk with the founder had not happened as of Oct 23, 2026.

Newest start, landing or closing date on a Phase One row: Oct 23, 2026.

No date for closing Phase One is published on this page.

How long has the handoff loop run unbroken?

Snapshot, not live Exported by hand on Nov 3, 2026 from records kept on one machine. Only a person refreshes it today.

The longest stretch the loop stayed open ran 15 h 21 min, 6 h 13 min of it declared idle. By the loop's log, its 18 iterations held an agent session open for at least 8 h 9 min of it, closer runs not counted. The log cannot show whether a person was working beside it.

A stretch is time the loop stayed open, not time without a person. It begins at a start line in the loop's log and ends at an end line or, when another start line follows with no end line, at the last timestamp logged before that start line. That inferred endpoint does not establish when the process stopped. The founder's own sessions ran beside the loop in the same days, and several stretches ended because one of them landed work. Nor is it how long a task an agent can complete. Anthropic's study of Claude Code reads autonomy from how long a turn runs, how often people interrupt it, how many sessions run with every action approved automatically and how often it stops to ask, with separate measures of risk and reversibility for agents on its API, and calls turn duration an imperfect proxy.

During these stretches each iteration worked in the founder's own checkout and could commit, use GitHub's command line in full, run any program through bash, sh or Python, and reach the network with curl. The first stretch with a recorded iteration return ran before the loop's script gained permission to push to main, which deploys production; every later stretch carried that grant. The writer fence and the landing gate came to the loop afterwards: on Oct 2, 2026 (decision D-0082) the founder ruled that it moves into its own clone inside the fence and lands only through the gate. No iteration on this record ran behind either.

The handoff loop starts a fresh agent session for each iteration: it reads the last written handoff, works, and writes the next. The handoff loop's log records 139 iterations in 26 stretches between Sep 22, 2026 and Sep 26, 2026, UTC days; timed by the log, they held an agent session open for at least 68 hours. Session time here is the log's, and a lower bound: it sums only iterations with both a reading line and a return line, from the line where the loop starts an iteration to the line where it returns, so an iteration with no logged return adds nothing. A run file's own timing is not used, because it covers only a session's last result and can read seconds for a session that ran for hours. The log has 6 iteration starts with no recorded return. Another 17 closer runs, which commit what an iteration left behind, are not counted in either figure. The most any stretch held was 33 iterations. The 5 longest, by wall time:

Of the 26 stretches, 9 ended with a person (a session landing work, or the founder's budget pause), 7 stopped at the loop's own checks or on a failed run (work left uncommitted, another writer's changes in its checkout, or a killed run whose result the budget check could not read), 6 were restarted with no cause in the log, 1 finished the iterations it was given, and the log gives no reason for 3.

In the run files that could be read, 24 of 155 sessions ended at their turn cap. The other 131 ended normally, which says the session closed, not that its work was kept.

Each stretch of the loop, by how it ended

One bar for each stretch, from its logged start to its end, on one clock in Central time, in a row for how it ended. Empty track lies outside the recorded intervals; around a restart, the log does not establish when activity stopped. Hover, drag or tap the chart, or focus it and use the arrow keys, to read one stretch.

26 stretches between Sep 21, 10:56 PM and Sep 26, 1:06 PM, Central time. The day ranges elsewhere on this page are UTC days: Sep 22, 2026 to Sep 26, 2026. Recorded stretches cover 81 of the 110 hours in that window; empty track lies outside the recorded intervals. 9 ended with a person. The loop's log records 139 iterations across them; the run files that could be read hold 138, and 4 run files, iterations and closers together, could not be read.

What this chart does not show. Halts and pauses: the record keeps them as totals, not times, so none is placed on the clock. Where idle time fell inside a stretch: the record keeps one total per stretch, so the bar does not mark it. Who restarted a stretch: a restart is inferred from a new start line, and the log never says who. Anything after the snapshot was cut: the record ends there.

No target line. No target for how long the Machine runs without a person is published. The goal under Where this is going carries no figure, so the chart draws none. Read the goal.

Counted November 3, 2026

A sprint that began on Sep 22, 2026 meant to run for a full day without a person did not finish unbroken. The long horizon runner, built to carry one goal across many sessions, This page has no committed operating record for it.

What stops the Machine?

These are the stops the record can count here, and one it cannot.

• Halts. Of the 23 commits that changed a halt file, from Jul 21, 2026 to Oct 15, 2026, 17 were recorded console commands: 8 pauses and 9 resumes, from Sep 11, 2026 to Oct 15, 2026. The record knows the other 6 only by commit author: 3 a person's account, 3 a bot other than the console. The daily pulse found no global halt file in place on Nov 6, 2026. Newest halt command: Oct 15, 2026. These count changes to halt files, not runs stopped.
• What a halt stops. A halt does not stop an agent that is already working. Each seat checks for one before its agent starts and, except for Finance Ledger, again before it lands anything, so a run under way when a halt lands is built to land nothing. The tests of the shared workflow every seat runs in show, against a disposable remote, that the check sees a halt that lands mid run; no live drill has shown it yet, and the drill that would stop a run in flight and leave a receipt had not been run as of the newest row date in the Phase One status file. The Autonomy Ledger's halted count reads 0, and is not a count of runs a halt stopped: a halted run's own record is kept only in that run's artifact, not on main.
• Cancel. The console can cancel a run in progress, which does not undo what the run already committed. It was pressed once, as a test, against a running seat, on Sep 15, 2026, and that record does not show the effect.
• The weekly budget. The loop has checked its weekly budget before each iteration only since the check was added, late on Sep 24, 2026 (decision D-0067), so its earlier iterations, that day's among them, ran with no check. Since then it read the budget within bounds 51 times and could not read it 1 time. The log names an empty run file, left by a run killed before it wrote its result. That read stopped the loop, on Sep 25, 2026, because the check fails closed: a budget it cannot read stops the loop. That run had exited on a signal with no turns, which the loop's log called a refusal by the model service and the commit that fixed the loop's reading calls a killed run. The unreadable read is what ended that stretch. It has stopped the loop for spending past the budget 0 times, so that stop has not yet been exercised.

  Counted November 3, 2026

• Stop at a boundary. A stop file ends the loop between iterations, a check added with the budget. Of the 12 stop files it met, 8 named a founder session landing work, 1 a founder budget pause, and 3 gave no reason.

  Counted November 3, 2026

• The automatic downgrade. A latch that returns every corrective rule above observe to observe when a set threshold trips or a gauge cannot be read. It tripped on Oct 25, 2026, because an error budget ran out and some of the gauges it reads could not be read, and its committed state reads tripped. No rule was above observe, so it changed nothing.
• The valve.

  A check that runs before each shell command and each connector call in a Claude Code session in this repository. It refuses commands shaped like a force push, a remote branch deletion, a recursive delete outside the temporary directory, destructive SQL, a credential rotation or a money movement, which stay a person's; a Codex run does not pass through it. It matches the text of each command against a short list of patterns, so it can refuse a harmless command whose text names a listed word and can miss a form it does not list: it is a second line, not the boundary. The hook does not maintain a denial log or counter, and this page has no denial count.

  Its force push rule and the session's second gate both key on the force flags, so a force push written in git's refspec form rather than with a flag matches neither.

  On main, GitHub's branch protection, read on Nov 5, 2026, refuses a force push and the branch's deletion for every account, administrators included, as the rule is configured. An account with admin rights can still change or remove that protection, and the valve has no rule for that call.

What is the path to self-driving AI?

Self-driving is a picture of where this road goes, and only a picture: a company whose work moves on its own, with a person who can still take over. The degrees on this page are the ones Morris and colleagues name. None is a driving level. On this page the path is the rollout ladder below, the staged order in which the organization's own parts turn on.

The evaluator is a script with no AI in it that scores the ladder's criteria. A halt is a file a seat checks before its agent starts and, except for Finance Ledger, again before it lands any work; a pre-staged halt is one the ladder wrote ahead of time to keep a seat dormant until its stage. The Inspector General is a seat with no agent behind it: it runs check modules against the organization.

The goal the road leads to is the Collective's own, quoted under What is autonomous operation.

1. Stage 0. The build

   Passed

   The org's guards exit clean, the org-foundation test file passes, the build lists no remaining items, and a baseline exists for every live seat.

2. Stage 1. The Quality seat live

   Passed

   What turns on: the evaluator clears the pre-staged halt on the Quality seat.

3. Stage 2. Agent Gauge scheduled

   Where the Machine is

   What turns on: the evaluator clears the pre-staged halt on the Inspector General, whose name is Agent Gauge, so its audit runs on a schedule.

4. Stage 3. The lesson protocol org-wide

   Next

   What turns on: the action's lessons gate opens. The action is the one shared workflow every seat runs in; once the gate opens, seats may write proposed lessons for later runs, and a proposal becomes memory only when it is promoted.

5. Stage 4. Surfacing only

   Later

   Nothing turns on automatically. The evaluator surfaces that the next phase's data gates are met, and activating it stays the founder's decision.

Counted November 6, 2026

The ladder is the first part of that road, not all of it, and this page does not map the rest. It activates stages already ratified, on committed evidence. It never grants authority, and its autonomous reach ends at its last stage.

The Machine moves up when each criterion at its stage is met by a check result, never by an agent's own assessment. At stage 2, those still unmet are Inspector General coverage and No org fabrication; what each requires is further down.

A person still signs the moves that matter. A rule leaves observe only by a logged decision. Promotions pause when no verifiable founder commit has landed recently. Past the ladder's last stage, going further stays the founder's decision.

The kill switch is a halt file. The global one stops every seat; a scoped one stops only its own seat, except a run a person dispatched to supervise. Each seat reads it before its agent starts and, except for Finance Ledger, again before a run under way lands its work. The ladder steps a stage back when a signal stays red, when the Inspector General names the stage, or when usage breaks a ceiling. When several seats go red in one window, it treats that as one problem: it asks the founder for one decision and does not roll stages back in a cascade. Stopping is part of the road. The rule is that a person lifts the halts people wrote.

Does the Machine repair itself yet?

Not on its own yet. Nothing has landed on main directly from it. The daily repair run reads the daily pulse, fixes what it may, and is refused what it may not. It runs on the founder's Mac on a timer.

Snapshot, not live Exported by hand on Nov 3, 2026 from records kept on one machine. Only a person refreshes it today.

• 0 direct landings on main.
• 3 pull requests opened, each because its change touched a path outside the closed list the run may land: 1 merged by the founder (Oct 4, 2026), 2 closed unmerged.
• 4 runs refused at landing, each because its change touched a path the landing gate refuses outright: a test that judges the work, or a change in a class the gate always stops. A file production serves, on its own, only opens a pull request. None of these landed, and none became a pull request.
• 3 runs stopped before the agent started, because the probe of the fence, the sandbox that confines the run's writes, could not run, so the fence was untested, never assumed up.
• 36 fence probes observed refusing on every leg they test, of 39 runs that started a probe; the other 3 are the untested runs above.
• 23 runs that ended in a report with no commit, from Oct 2, 2026 to Nov 3, 2026.

Counted November 3, 2026

How is this measured, and what is not?

The seats completed 181 of 198 recorded runs, 91.4 percent, since Jul 21, 2026, and 17 failed. A completed run is one whose output survived the completion gate, the lane check and the guards, and landed. Left out of both sides: skipped runs, 10; halted runs, 0; and runs the harness itself decided, 4. A separate counter, 129, counts files erased as out of lane before a commit. Seat runs are recorded by the workflows themselves; a committed correction naming its run can move a run the harness itself decided out of a seat's count. The organization is grading itself, and the sample is small.

The opening baseline, frozen on Aug 11, 2026, was 30 runs at 80.0 percent. The completion gate changed on Sep 20, 2026 (decision D-0061): since then a healthy run is judged on the harness's own measurements, not on the agent's own completion line. The opening baseline was measured before that change, and so were the earlier runs counted in the current rate, so the two rates are not measured the same way and the current one spans the change.

Counted November 6, 2026

Founder time on the record is at least 370 hours, from Jul 6, 2026 to Oct 19, 2026, and 99 percent of it is unclassified. The intervention record is a floor, not a series. Most of its time is not yet classified, so it cannot say how much of the work needed a person.

Counted October 22, 2026

The improvement record, read here from its committed file as of the date shown below, counts failures attributed to the Machine or a person, plus failures that are unattributed or unparsed. Its window runs from Oct 8, 2026 to Nov 4, 2026. The record counts 1 failure in that window: 0 found by the Machine and 1 by a person. It is a partial count; what it leaves out is listed under what is not measured.

Counted November 4, 2026

What is not measured

• The valve keeps no denial log or counter, so this page has no denial count.
• Signed halt lifts are not counted.
• Runs a halt stopped are not counted on main: their records stay in each run's artifact, and no drill has yet stopped a run in flight.
• Whether each loop iteration's work was kept or reverted is not recorded.
• A correction the founder makes as a call in a handoff has no record format yet, so it is left out of the count above of who found each failure.
• The loop's record lives on one machine and ends the day the loop was paused. Only a person refreshes it today.

What would move the Machine forward?

The ladder names what it is waiting for.

1. Inspector General coverage. Requires the Inspector General to publish what it covered: the modules it ran and what each one examined, against a declared floor.
2. No org fabrication. Requires an Inspector General module aimed at the organization itself to measure its subject and find no fabrication.

The ladder records why each one is unmet in its own note, published with the daily pulse. Read the pulse.

Counted November 6, 2026

Some things stay the founder's however far the Machine moves: money, claims made in public, anything irreversible, and the gates themselves.

Writing on autonomous operation

AI Agents · 10-30-2026 · 7 min read

Can Someone Else Run the Machine?

A proposed handoff test of whether another operator can run the Machine. Proposed, not run.

AI Agents · 10-23-2026 · 9 min read

The Agent Never Ran. Neither Did Its Alarm.

Work that never starts. A proposed lane for noticing it, which does not claim company wide autonomy.

AI Agents · 10-10-2026 · 6 min read

The Sandbox Failed. It Reported Success.

A sandbox that reported success while most of its agent runs did nothing, and what a gate has to see.

AI Agents · 10-04-2026 · 5 min read

When Do I Get to Leave the Loop?

Human in the loop as a set of gates, each opening on evidence defined in advance, and the ones that never will.

AI Agents · 09-28-2026 · 7 min read

Governing an agent leadership team

A kill switch that is a file, and liveness that reports not observed instead of clean.

AI Build · 09-25-2026 · 9 min read

Twelve seats, no people, and a check that blocks my own commits

What the seats may do alone, what they may never touch, and the check that refuses the founder.

AI Engineering · 09-01-2026 · 5 min read

Self-Healing Is a Euphemism.

Bounded repairs that each restore a known good state and log that they ran. Not the daily repair run counted here.

AI Agents · 08-12-2026 · 9 min read

Long Horizon Agents Don't Fail. They Pass.

Long tasks fail green: every test passes while the work goes wrong. Passing is not finishing.

Read further

• Glossary: autonomy

  The degrees of autonomy, and where the Machine publishes its own.

• Glossary: the ladder

  The staged rollout that holds, promotes or rolls back on committed evidence.

• Kill switch

  A Methods page: each stop, how fast it takes effect and what it does not stop.

• Glossary: kill switch

  A committed halt file, read before a seat's agent starts and, except for Finance Ledger, again before it lands anything: one stops every seat, a scoped one only its own.

• Glossary: Collaborative mode

  How the Machine runs today.

• Glossary: Autonomous mode

  The mode still being built.

• The Autonomy Ledger

  Every seat's runs, completions, failures and discards, and how a completed run is defined.

• Governing an Agent Leadership Team

  The governance preprint. Self published, not peer reviewed.

• Morris et al., Position: Levels of AGI for Operationalizing Progress on the Path to AGI (opens in a new tab)

  The levels of autonomy this page maps onto. ICML 2024, PMLR volume 235, pages 36308 to 36321.

• Parasuraman, Sheridan and Wickens, A model for types and levels of human interaction with automation (opens in a new tab)

  The earlier human factors model: four classes of function, each automated across a continuum from fully manual to fully automatic. Morris and colleagues set their framing apart from it, and this page's levels do not come from it. IEEE Transactions on Systems, Man, and Cybernetics, Part A, vol. 30, no. 3, 2000.

• Feng, McDonald and Zhang, Levels of Autonomy for AI Agents (opens in a new tab)

  Five levels defined by the role the user takes: operator, collaborator, consultant, approver and observer. A different scale from the one this page maps onto. Knight First Amendment Institute, 2025.

• Anthropic, Measuring AI agent autonomy in practice (opens in a new tab)

  Reads autonomy in Claude Code from turn duration, interrupts, auto approval and the stops the agent makes to ask, and on the API from human involvement, risk and autonomy scores and reversibility. Calls turn duration an imperfect proxy for autonomy. A different unit from this page's stretches. Published Feb 18, 2026.

• Anthropic, Effective harnesses for long-running agents (opens in a new tab)

  The pattern the handoff loop follows: each new session begins with no memory of the last, and picks up from a progress file and the git history. Published Nov 26, 2025.

• Shavit and colleagues, Practices for Governing Agentic AI Systems (opens in a new tab)

  OpenAI's paper on governing agentic systems. Its section on interruptibility names two hard cases: stopping an agent in the middle of a sequence of actions, and an agent that interferes with its own shutdown. A halt on this page is read before a seat's agent starts and, except for Finance Ledger, again before it lands its work; it does not interrupt the agent mid-action.