Sovereign Fleet is learning to do work that is not code. The part everything rests on is the tool server: a third-party MCP server confined by the kernel, reachable only through a gate the fleet owns. What is built, what is proven by test or measurement, and what is still open.

A Browser for a Sandboxed Agent: How Sovereign Fleet Confines Third-Party Tools

Sovereign Fleet takes a coding task, runs an agent on it inside a kernel sandbox, checks the result at a gate and lands the commit only when the gate is green. On 2026-11-14 I asked a different question: can the same machine run work for me that is not code? Read a few pages, pull numbers from an interface, write a report, later fill in a form.

The fleet’s proof is a gate script on a git branch. Nothing in that is limited to code. Any job whose result is a file is a task in a repository, so intake, sandbox, budget, gate and approval apply unchanged. What is missing is hands. An agent that should read a rendered page needs a browser, and a browser is the largest piece of attack surface you can give to a program that reads text written by strangers.

This article is about that foundation, the tool server. Because everything else rests on it, I set the bar high: fast, fault-tolerant, scalable and secure, each with a test or measurement I can point to. The honest answer today is “the core yes, the whole not yet”. Both halves are below.

The feature this carries is called Privateer. Why it has that name, and where it stands next to the agents you can buy, is in the companion piece.

What I decided not to build

The maintenance rule for this upgrade is short. Capabilities come from third-party MCP servers that somebody else maintains. The fleet owns a thin layer around them and nothing more.

That also settles the positioning. The fleet is not another assistant and does not compete with OpenClaw or Claude Cowork. An assistant sits in front, talks, remembers and hands over work. Agents sit inside as workers. The fleet is the layer between them that bounds what a worker can do and proves what it did. So there will be no messenger gateway, no conversational memory and no skill market in it.

The first attempt failed in the right place

Experiment E1 was the cheap test: one goose run in the unchanged fleet sandbox with Playwright MCP 0.0.79 as a stdio extension, the local 35B model, one task. Open a page with the browser tool and write its title into a file.

What was triedResult
Chromium headless_shell --dump-dom under the task’s sandbox policyworks
The full chrome binary under the same policyfails: the seccomp filter denies socket(AF_UNIX)
goose with Playwright MCP as an extension inside the sandboxthe extension loads, the browser does not start: the server opens a unix socket for its browser
Playwright MCP as its own process outside the sandbox, reached over loopbackworks, 5 seconds

The fourth row works and is wrong. The browser ran unconfined, and its traffic appeared in no fleet log. Loosening the unix-socket block for it was not an option either. Pathname unix sockets are not covered by Landlock on this kernel, so a browser that parses hostile pages would have reached the session bus, the Docker socket and the sockets of other agents.

E1 had a second result that shaped everything after it. In all three failed runs the model fetched the page with curl instead and wrote the correct title, although the task said the title must come from the browser tool. Twice it reported the switch. Once it reported plain success. An agent whose tool fails finds another way and may not say so. The check that follows from this never reads the agent’s own account. It reads where a value came from, in logs the agent cannot write.

The design: one more sandbox, pipes, no port

agent (strict sandbox A) --HTTP on loopback, token in the path--> tool gate (in the fleet daemon)
                                                                   | rules, budgets, timeouts, call log
                                                                   | stdin/stdout pipes, no port
                                                         capability server (strict sandbox B)
                                                                   | only way out
                                                         egress proxy B: the task's domains, logged

The capability server runs in the same strict sandbox profile as an agent, as a separate instance. It can write one scratch directory. It can read the system, its runtime, its own pinned package and the browser binary. It sees no home directory and no credentials, because its environment is built from nothing. Its only TCP destination is an egress proxy of its own, which knows the domains of this one task and logs every attempt.

The gate talks to the server over stdin and stdout. Stdio is the transport every MCP server has. Because there is no upstream port, there is nothing an agent could connect to in order to walk around the gate, no port to collide between tasks, and the server lives exactly as long as its parent process. Towards the agent the gate is a plain streamable-HTTP MCP server on loopback with a random token in the path, so any harness can attach it.

I rejected three alternatives. Loosening the socket block, for the reason above. Bubblewrap, because unprivileged user namespaces are blocked by AppArmor here and on stock Ubuntu, so it would need a profile installed by root. A container per task works, but it adds a root daemon and an image to maintain; it stays a later option for servers that cannot live without unix sockets.

The design forced a change of browser server. Playwright MCP 0.0.79 always binds a unix socket for its browser, with no switch to turn that off. chrome-devtools-mcp 1.13.0 does not, and it has flags for what I want off at the source: a proxy, an isolated profile, no usage statistics, no script evaluation, no file navigation.

Experiment E3 ran it over stdio with Chromium’s headless shell inside the unchanged strict sandbox, with a proxy that allowed example.com and nothing else. The server was ready in 0.35 s, the first page took 1.4 s, a snapshot 0.03 s. A page off the list failed with ERR_TUNNEL_CONNECTION_FAILED and showed up in the log as refused. A request to a local address went to the proxy and was refused there. The server’s own update check was refused and logged. Closing stdin ended server and browser with no process left behind. Chromium’s inner sandbox is off, because it needs user namespaces. The outer one is the kernel policy.

A hole I found on the way

The strict sandbox did not filter UDP. Landlock restricts TCP connections only, and a sandboxed process sent a UDP packet to a port outside its list. With a domain allowlist in place, that is DNS tunnelling and QUIC past the proxy, for every agent already running and for a compromised browser later.

The fix is a seccomp rule: behind an egress proxy a process gets TCP and netlink sockets and no other family. The test for it fails on the old code. This hole existed before the upgrade and would have stayed without it.

What a capability looks like

A new capability is one config block. This is the block experiment E4 ran with, copied from the repository with the two long local paths shortened. The memory limit was 3 GB in that run; after the measurements below, the block for daily use carries 1 GB, and current config validation also requires a non-empty effects declaration (refusing allow on side-effect tools such as send, publish, pay, delete, or restart) plus optional pin and manifest_sha256 checks.

[capabilities.browser]
command = ["node", "<npx cache>/chrome-devtools-mcp/out/Default/gen/src/bin/chrome-devtools-mcp.js",
  "--headless", "--isolated", "--executablePath", "<browser cache>/chrome-linux/headless_shell", "--proxyServer", "{proxy}",
  "--no-usage-statistics", "--no-performance-crux", "--no-page-id-routing",
  "--chromeArg=--no-sandbox", "--chromeArg=--proxy-bypass-list=<-loopback>", "--chromeArg=--disable-quic"]
read_only = ["<npx cache>/node_modules", "<browser cache>/chrome-linux"]
rules = { navigate_page = "allow", take_snapshot = "allow", list_pages = "allow", wait_for = "allow", click = "allow" }
max_calls = 30
max_calls_per_tool = { navigate_page = 8 }
call_timeout = 60
memory_max = "3G"

A tool without a rule is denied, and the agent is not even shown it: in E4 it saw 5 of the server’s 33 tools. The budget counts calls at the gate. The egress proxy cannot do that, because HTTPS passes it as a tunnel and it sees connections, not requests. A task asks for the capability by name and brings its own domain list.

Requirements and proof

Each row counts as met only with a test or a measurement. The full table with test names is in the spec in the repository; this is the short form.

RequirementProofState
The agent reaches a capability only through the gatethe server has no port; test: the agent’s policy holds the gate’s port, another local port is deniedmet
The server is confined separately and holds no credentialstest: home neither readable nor writable, empty environment, one scratch directorymet
Every request passes a proxy with the task’s domains onlytests (including fail-closed startup and 502 on unwritable log), plus the logs of E3 and E4met
No UDP and no other socket family behind a proxykernel test that fails on the old codemet
Default deny per tooltests; the agent is shown allowed tools onlymet
Pinned tool list: a changed list refuses to startthree testsmet; the pin is a fixed value in the config, no trust on first use
Package pinned by version and integrityread-only package dirs outside writable paths (chmod a-w), update check refused and logged, Capability.start() verifies manifest_sha256 over every file in read_only, and config validation rejects RO/RW overlapmet
No secret in a log, arguments cut or hashed, log hash-chainedtests; URL user:pass@ credentials stripped before logging call args, reasons, bodies, and provenancemet
A result is untrusted data with a size limittest; the server’s own instructions are droppedmet
The agent starts only after the capability answeredtests, seen live in E4met
Timeout per call, readable error from a hung or dead servertestsmet
Teardown always, whole process group and scratch directorytestsmet, also at daemon start
Own memory limit per capabilitysystemd scope; test: a server that allocates past its limit is killed and the next call says somet
Same behaviour for every harnessgoose: E4. Claude Code: one real run, 12.4 s, page read, the page off the list blocked, log intactmet for these two; other harnesses refuse such a task
N tasks are N isolated instancestest with eight gates, benchmark with 50; eight browsers on a trivial page: 189.8 MiB each at the median by the cgroup’s count; four on a static copy of a heavy 530 kB page: 242.8 MiB median, 250.8 MiB peakmet; about four times headroom under the 1 GB limit
No shared scratch space between sandboxesprivate_tmp = true is the default on capability blocks, giving each run a private temporary directory while denying shared /tmp (tests verify PermissionError on /tmp inside Landlock)met for capabilities; agent harness sandboxes still keep shared /tmp
Side-effect tools require explicit approvalevery capability requires non-empty effects; "ask" writes a CallLog-bound draft capped by max_drafts, pushes full arguments to Matrix, refuses batch task approval, serializes single execution with fcntl.flock in a fresh capability; still open: authenticating draft approval strictly via an off-host operator Nostr signature instead of the shared bearer tokenpartial (signature auth open)
Result evidence verified without trusting the modelnative evidence gate reads call logs, response bodies, egress logs, source HTTPS checks (unless allow_insecure_http = true), and shared cache provenance; verified external faults end retry rotation as could_notmet

The gate is not the bottleneck. For one task its overhead is 0.37 ms at the median and 2.2 ms for a 100 kB answer. With 20 tasks at five calls per second each, the median is 2.0 ms and the 99th percentile 5.2 ms. One core saturates at about 2100 small calls per second. A page call takes 20 to 800 ms and a model turn takes seconds.

Experiment E4 was the whole path on a copy of the live config: goose with the local 35B, a task that names the browser capability and example.com as its only domain, chrome-devtools-mcp confined with the socket filter and a 3 GB memory scope. Thirteen seconds, three browser calls, the title correct. A second page off the list was refused, and the agent reported that honestly. The call log verified, the capability’s egress log showed one allowed and two refused hosts, and nothing was left running.

Can a local model carry such a job?

That was the larger risk, so experiment E2 measured it before more was built. Three read-only jobs from the planned pilot, two runs per model: four wind values from a weather interface, a list of 26 lift companies from the right section of a page, and a navigation task from a home page to two numbers. The browser tasks ran against static copies of the pages.

ModelwindliftsnavigationPage actions per browser taskSeconds per browser task
Qwen3.6-35B, local, production2/22/22/217 to 4856 to 180
Qwen3.8-27B, local1/22/22/212 to 42349 to 789
Qwen3.8-Flash-Next, local, needs the whole machine2/22/22/28 to 2045 to 103
Claude Sonnet 5.5, as yardstick2/21/22/28 to 2126 to 48

The model that runs here anyway solved every run by the intended route. The limits of this are plain: two runs per cell, three jobs, friendly pages, no login, no form.

The side findings matter more than the scores. An earlier round against the live site ended in HTTP 429, because the 35B made about 130 page actions in a quarter of an hour. A small model costs the visited site several times the requests of a strong one, and the count varies by a factor of two to three between two runs of the same model. So a request budget has to be a hard limit in the gate, which is where max_calls came from. Claude’s one miss was an honest “could not find the section”, which is wrong by the score and right by the rules. And the 27B once ignored the output contract and wrote a prose verdict in place of the result file. The lesson for the gate: the schema of the result file is checked, free text is not a result, and any judgement comes from a fixed rule and never from the model.

Why there is no agent framework in it

A fair question at this point: plan, act, verify, adjust is what LangGraph, PydanticAI, LlamaIndex Workflows and CrewAI are built for. Why not put one of them inside? I looked at them for this upgrade. I have not run any of them against my own endpoint, so what follows is a design argument and not a benchmark.

The fleet already is that loop, one level further out. An agent works in a sandbox, the gate decides, and a failed attempt hands its failure to the next one. This is the whole “adjust” step, from core/engine.py:

    def _prompt(self, task: FleetTask, failure: str = "") -> str:
        prompt = task.text
        if failure:
            prompt += ("\n\nA previous attempt on this task did not pass verification:\n"
                       f"{failure[-1500:]}\n\nKeep what is right in the working tree, fix exactly this, "
                       "and change nothing else.")

After that comes the next lane, and after three real failures one attempt on a frontier model. A graph framework inside the engine would be a second control plane beside the task store, the approvals and the router. Inside a worker it would be one more agent, and the fleet has seven of those as plugins.

Four things the fleet does differently on purpose:

  1. The judge is never a model that did the work. In role-based frameworks a reviewer agent usually checks the worker agent. Here a test, a schema or a log decides. E1 showed why: the model reported success on a route the task had forbidden.
  2. Limits live in the kernel and in code, not in a prompt or a step counter. A recursion limit stops a loop. It does not stop a process from opening a socket. Scope, network, call budget and time are enforced where the agent cannot argue.
  3. The context does not grow. Every attempt starts from the state of the working tree and the tail of the last failure. There is no transcript to prune, so there is no pruning strategy to get wrong.
  4. Structured output does not depend on tool calling. Local models miss tool calls more often than hosted ones: 25 and 23 of 28 in my own bench for the two newer Qwen models. So where the fleet itself asks a model for data, the answer is forced into a JSON schema by the server and validated in code.

For narrow tasks an inner loop is still useful, and it needs no framework. The reference pattern in the repository is about 70 lines: the model returns whole files under a schema, pytest decides, and hard limits end the loop. It ran once against the local 35B on a toy repository with two faults, failed in round one and passed in round two. That shows the pattern works, not how far it carries.

Where the frameworks are ahead: durable checkpoints in the middle of a long run, and ready-made retries on a typed answer.

Where the fleet failed at building its own foundation

I had the fleet build these pieces first. The record is not flattering, and it belongs here.

The fleet’s own tool gate passed its gate and its review with a module that did not speak HTTP and allowed read-looking tools by itself. The agent had written the tests to fit its code. The task for per-task domains landed without the validation its criteria demanded. The UDP fix failed on three lanes. The coordinating agent, Claude Code in this case, then wrote the gate, the capability module and the socket filter itself, with a real client and a real kernel test as proof.

The rule I took from it: for protocol and security code the coordinator supplies the proof or writes the piece. A test written by the same agent as the code proves that the two agree with each other.

It cut the other way too. The new tests start local servers and open probe sockets, and the fleet runs its repository gate inside its own sandbox, where both are denied. Two follow-up tasks failed at that gate on tests that could not pass there, one of them on every lane it was given, before the tests learned to skip inside a sandbox. A sandbox that tests itself needs to know when it is inside one.

The same day produced one more rule. A task that really fails on three lanes now goes to a frontier lane for exactly one attempt, even when that provider’s budget policy says “manual”. Privacy and quota blocks still hold. The first two real escalations then died at a login prompt that nobody answers inside a daemon, and the second frontier lane was never tried. An attempt that fails before the agent starts working no longer counts as the one attempt. After review, ordinary error code 2 stays a real failure unless the output also matches an auth or start-failure pattern; a pre-work authentication failure rests its own login group so the next task does not wait 60 s again and shows up in lane health, while a local lane printing auth-like text takes only the short rate-limit pause (120 s). I have not yet seen the rule rescue a task.

Status on 2026-11-16

The first real job will be a wind and snow report for my home region, with fixed limits that I set and a record of forecast against reality. That gets its own article, with its own numbers.

Why the feature is called Privateer: a letter of marque for an agent. Overview and current status: the Sovereign Fleet project page. Earlier parts of this log: the fleet’s architecture and its audit and the fleet on Nostr.

Was this worth it? Zap the article.

Value for value, no signup. Sats go straight to the writer.

… sats zapped
… zaps
Today 7d 30d All-time
Unique readers — — — —
Page views — — — —
—
All Article Insights →