Every page, by package

The inbrowser monorepo: a resumable job engine, an inference relay, an agent runtime, and an on-device model engine.

Repo shape, conventions, and invariants for agents working across the monorepo.

Agent runtime plus an agent-friendly CLI: AgentSession, AgentStrategy, ToolRegistry, ModelClient, and an `agent` binary.

Build a complete agent session in TypeScript with a scripted LLM (no API key or network) that calls a tool then writes a reply.

Drive the `agent` binary: discover its schema, run a scripted scenario, read the NDJSON event stream, and find the durable session log.

Expose your own tools to an external host over MCP: define an agent, stand up an MCP stdio server, and point a host at it.

Plug an upstream LLM API into a session by implementing the narrow `ModelClient.chat()` async generator and mapping its stream to ModelEvents.

Give an agent the tools from an external MCP server with `connectMcpTools`, so the session calls them through the same in-process loop.

Define a ToolHandler, register it in a ToolRegistry, and dispatch it, including mutating session state and marking read-only tools parallel-safe.

Audit what an agent did to a project and reverse a mutating commit using the `agent` CLI against the per-project append-only event log.

The public library surface of `@inbrowser/agent`, exposed across three import subpaths.

The `agent` binary, derived from CLI_SPEC, the single source of truth the parser and the schema/describe commands surface verbatim.

The three discriminated-union event streams in `@inbrowser/agent`, each a typed AsyncIterable consumed at a different layer.

The two ways to consume the package come down to who owns the loop, the single most important mental model for working with it.

What createReactLoopStrategy() is, why it is shaped that way, and the trade-offs baked into its two optional behaviours.

Invariants, anti-patterns, and workflow patterns for driving the agent runtime and CLI.

Step-by-step skill for running sessions, fleets, event-sourced audit/undo, and forward replay through the CLI.

Browser-native workspace runtime: OPFS/memory files, esbuild preview compilation, jailed browser shell, isomorphic-git, package import maps, and optional agent tool adapters.

Create a browser workspace, write a tiny React app into /work, and prepare file, shell, and git services for an app-builder agent.

Preview a React/TSX app by compiling the workspace entry module and evaluating it with host-provided React modules.

The public surface of @inbrowser/workspace: workspace creation, file systems, preview, shell, git, packages, and agent tools.

Why the workspace runtime chooses compile-and-mount preview, host modules, structured shell/git/package services, and explicit limits over a partial browser Node illusion.

Sandbox orchestration above @inbrowser/workspace: runtime events, standard agent tools, checkpoints, and a workspace adapter for browser-native app builders.

Expose browser workspace tools to an @inbrowser/agent session with @inbrowser/sandbox and the @inbrowser/agent/sandbox bridge.

Create, restore, query, and prune sandbox checkpoints with turn, message, and tool-call metadata for agent-session restore flows.

The public surface of @inbrowser/sandbox: sandbox contracts, workspace adapter, standard tools, checkpoints, events, and the agent bridge.

How @inbrowser/sandbox absorbs Piebox-shaped orchestration into the inbrowser package suite while keeping runtime substrate, workspace services, and agent loops separate.

How Apple container, WSL containers, and similar remote Linux runtimes fit into the sandbox boundary while the browser renders results.

Why sandbox side effects stay on the sandbox, agent policy stays in @inbrowser/agent, and createSandboxAgentTools adapts between them.

Package invariants for sandbox tools, events, checkpoints, and workspace adapters.

Resumable LLM inference relay: a pure transport that serves ModelClient factories from @inbrowser/model over HTTP, plus a reconnecting browser client.

Build a relay over a memory store and a fake provider, start a job, stream it, and resume from an offset.

Mount the relay in Astro, Express, or any Web-standard runtime, and consume the stream from the browser.

Implement a ModelClient for an upstream LLM: parse SSE upstreams, emit ModelEvent tool calls, and register it as a ModelClientFactory.

Reach Claude through a subscription with no API key, using the claude-code (Agent SDK) or claude-cli (claude -p) providers.

createRelay, NormalizedRequest, the re-exported ModelEvent/ModelClient contract types, ModelClientFactory, the handlers, adapters, SSE helpers, and the client.

The job lifecycle, why providers and adapters are separate, what is stored, and offset-based replay.

Resumable streaming-job engine: a pluggable JobStore plus a JobEngine that streams events into a durable, tailable log.

Create the engine, start a producer, read the stream, replay from an offset, and stop cleanly.

Configure the Firebase RTDB store, add the sweep index, use a service-account token provider, and verify durability.

createJobEngine, the producer surface, subscription events, the JobStore contract, memory + RTDB stores, and sweeps.

Engine and store, sequence numbers as the resume contract, terminal state vs events, and TTL retention.

The model layer: the lightweight ModelClient contract at the root, cloud providers under @inbrowser/model/providers/<name>, and an opt-in on-device LLM engine under @inbrowser/model/local.

Load a small language model into a browser tab and stream its reply token by token, with no server, API key, or cloud inference.

Move the same engine into a Web Worker so the model loads and decodes off the main thread and the page stays responsive.

Pick the bundled ModelPreset whose declared capabilities and download cost match what your app needs, or define your own.

Wrap an on-device engine as a ModelClient with createEngineModelClient, then expose it through a relay provider factory.

Wrap an on-device engine with createEngineModelClient and pass it directly as an agent session's llm.

Separate a model's reasoning trace and tool-call envelopes out of the raw token stream so you can route them to different surfaces.

The @inbrowser/model/local export: the engine factory, the Engine surface, the event vocabulary, and the stream transformers.

The @inbrowser/model/local export: the bundled ModelPreset values and the static types they carry.

The worker helpers in @inbrowser/model/local that host an Engine in a Web Worker and connect to it behind the same Engine surface.

OpenRouter and Requesty configuration, attribution headers, reasoning controls, usage telemetry, and shared OpenAI tool encoding.

The load-bearing decisions behind the small Engine surface and the trade-offs each one accepts.

The stack that makes running an LLM in a browser tab possible, the constraints it imposes, and why you would choose it over the cloud.

Purpose, layering invariants, and vocabulary for the on-device model engine.