Omniscio

Agent action throttles

What pacing Omniscio still applies to agent actions and what it deliberately no longer does: the retired filesystem and PID throttles that stay off, the correctness and safety protections that remain, and the authenticated admission broker that ships on with the app and paces heavy work by class.

On this page

What it is

Settings → Performance

The former filesystem/PID throttles are retired and off. Historic saved on values do not turn them back on. In particular, Omniscio no longer delays every shell command, so an ordinary command does not wait for a slot, run a PowerShell process probe, or read a pacing file.

The switches for search, Git, installs, shell commands, new-session starts, and worktree creation remain visible temporarily for settings compatibility. They are labeled experimental/reserved and default off. They do not activate the retired implementation.

Where to find it

The switches for search, Git, installs, shell commands, new-session starts, and worktree creation are kept visible in Settings → Performance temporarily for settings compatibility — labeled experimental/reserved and default off. The broker pacing described below is the exception: no Settings screen renders it, so it is changed through the settings API or the CLI, never from a switch on that page.

How it behaves

Protections that remain active

Removing pacing did not remove correctness or narrow safety controls:

  • Git keeps bounded thread counts and no-lazy-fetch safeguards.
  • Broad search keeps root rejection and junk-folder exclusions.
  • find batching/pruning remains independently enabled by default because it prevents one command from creating a process per file.
  • Worktree mutations still go through Dev Pipeline authority.
  • Compiler/toolchain enforcement remains active.
  • Critical automated recovery still respects the memory-cliff protection.
  • Dependency writes still require the package-store integrity fence.

These controls do not queue ordinary commands.

The one wait: a heavy Git verb while the machine is out of memory

One thing on this page does delay an agent. When Omniscio's own memory verdict says the computer is out of memory — available RAM under its floor, or commit room under its reserve — an agent's heavy Git verb (status, fetch, merge, rebase, blame, grep, a mutating worktree verb and the rest of the heavy set) waits, then runs. A cheap read (rev-parse, branch, a plain log) never waits, and neither does anything while the verdict is calm.

  • The wait is capped at 30 seconds and the command then runs anyway, so an agent is slowed, never stuck. The agent sees one line on stderr saying how long it waited.
  • On a calm machine the check costs the agent's shell nothing: it reads a small file the app already publishes, with shell builtins, and starts no extra process.
  • It reaches the agent's shell only. Your own terminal, and anything you launch by hand, never waits.
  • AMC_DISABLE_MEMORY_RESUME_HOLD=1 turns it off, the same switch that stands down the heavy-run wait described in the memory-pressure contract.

Next-generation broker

Omniscio includes a new authenticated local broker for explicitly classified heavy work. Since 2026-09-08 the broker sidecar starts with the app by default, and pacing ships ON with it: the app setting admissionBrokerV2Enabled defaults to on, so an app-spawned session is handed the broker variables and paces git-heavy plus the classes the default class list names. It is not a blanket shell gate — a session gets the broker variables only while pacing is on and the sidecar is ready, and ordinary commands, cheap Git and small searches do no broker I/O at all.

Narrowing or switching pacing off, either way, on the app:

  • the setting admissionBrokerV2Enabled — read per spawn, so a flip reaches the next session with no restart; set it to off to stop pacing entirely, and with no class list a session is handed git-heavy,build-test,git-rebase,ready-mint,cloud-control;
  • or AMC_ADMISSION_BROKER_V2_CLASSES=<comma-separated classes> for an explicit list (the app injects AMC_ENABLE_ADMISSION_BROKER_V2=1 into sessions for you either way).

Available classes are recursive-search, git-heavy, process-start-heavy, build-test, git-rebase, ready-mint, cloud-control, and install. Five of them pace by default: the four the default class list enables — build-test, git-rebase, ready-mint, cloud-control, each sized from a measurement of its own contention — plus git-heavy, which is the class the app adds on top of that list so that switching pacing on can never mean pacing nothing. The other three (recursive-search, process-start-heavy, install) stay dormant until their own crash, latency and long-soak evidence is complete.

An explicit AMC_ADMISSION_BROKER_V2_CLASSES list replaces that default set outright: a class left off the list stops being paced, git-heavy included. AMC_DISABLE_ADMISSION_BROKER_V2=1 is the master rollback and wins over enablement; AMC_ENABLE_ADMISSION_BROKER_V2=0 on the app turns the sidecar itself off. Class enablement is independent; turning on one class does not pace the others.

Those two variables are necessary, not sufficient. A lease also needs an endpoint and a credential, and the credential is handed out only at session spawn, so a process that is not a descendant of an Omniscio-spawned session — a gate .cmd under the Windows Task Scheduler, the cloud dispatch daemon — cannot get one at any flag setting. Check for a live \\.\pipe\omniscio-agent-admission-* before assuming a class is active; measured 2026-09-05, none existed and 4,731 consecutive requests were no-ops.

If the broker is unavailable, safe read work degrades immediately, build/test or heavy process work returns no verdict, and package mutation refuses. It never waits to a ceiling and then releases the same queued cohort unpaced.

Large fleets

Idle agents and ordinary commands open no broker connection. The broker is designed to scale with concurrent heavy operations, not total session count. Keeping 200 local agent processes resident is a separate hardware question: RAM/commit, Windows process and desktop-heap limits, file handles, and simultaneous Git metadata reads still cost real resources. Use remote execution or a smaller active local set if the machine cannot carry that resident footprint.

The notice that costs nothing: what your git command actually burned

Omniscio does not pace git. It does tell an agent, in its own session, when git is costing more than it needs to — because an agent that never hears about it runs the same expensive command again an hour later. Two things raise one short note:

  • One costly command — a git command belonging to a session that has used 30 CPU-seconds or more. For scale: a normal git call finishes in well under a second, while a diff or merge-tree between a far-behind base and a head has been measured at 111-174 CPU-seconds.
  • A burst of programs while git keeps running — a session that started 300 processes in ten minutes while git was running throughout. That is the shape of a script looping over items and shelling out once per item — and equally the shape of a land, a PR or a build, because the count is every program the session started (npm, node, powershell, a launcher), not only git. The note says so, and offers its batching advice only if a script of yours is calling git once per item.

The note names the command shape, the cost it measured, and the cheaper form: diff from git merge-base instead of a far-behind ref, add --no-renames when you only need file names, use one git cat-file --batch or one git ls-tree -r instead of one call per item, and never run two expensive reads at the same time.

It only tells you. It never blocks, kills or slows a command. It arrives at your session's next turn boundary, not in the middle of one. It is capped at one per command shape per session per 30 minutes, so a session that runs ten expensive commands learns once or twice rather than ten times.

It costs the computer nothing to run: it reads the process table Omniscio was already reading for its own reasons, starts no process, runs no git command, and keeps no timer of its own. The one bit of extra sampling only happens while a git command is actually alive.

The note is written for the AGENT, so it does not appear in your conversation: it is folded out of the transcript and comes back only when you turn on Show system messages for that session.

Its honest limit: it can only notice a command it managed to observe while the command was running, so a very short git command may pass unseen — which is exactly when it is too cheap to matter. Turn the whole thing off with AMC_DISABLE_GIT_COST_WATCH=1.

  • Pace heavy background jobs
  • Computer feels slow?
  • Testing regimes — Omniscio’s internal, developer-only guide to which verification harness fits which job; it is not shipped to customers.

Last verified 2026-11-04