Build agent systems that do the work.

Define what an agent can be in file-routed TypeScript. Foundry persists what each live agent has installed, assembles it for the current message, and runs the whole system with end-to-end types.

Create many live agents from one definition. Each instance can have its own applications, playbooks, schedules, workspace, context, and multiple conversations—and be reconstructed after a restart.

Follow an inbound event through its matching playbook, provisioned agents, conversations, handoffs, tool calls, artifacts, and final outcomes without exposing private chain-of-thought.

Open websites, inspect pages, click, type, and take screenshots. Compose browser actions and page evaluation in one script through mountBrowser. Keep the agent's model and choose the backend through an adapter.

Give an agent a place to write code, execute commands, and start servers. mountSandbox exposes files, processes, and services through a scriptable adapter. Choose which workspaces and services persist across runs.

Start Foundry and it starts its Station daemon. Run agent jobs and optional browser and sandbox providers on that same instance. Foundry owns startup and shutdown; each agent receives access through explicit mounts.

Tools push React components onto a stack — product grids, forms, confirmations — rendered inline, mid-conversation. Pause for input with pushAndWait or stream results with pushAndForget.

A complete voice pipeline — STT → agent → TTS — with barge-in, push-to-talk, and narration. Every tool and display slot keeps working, spoken instead of typed.

Run the same agent on a realtime model — 500–800ms voice-to-voice, turn-taking decided by the model listening. Then give it a face, and put it in a LiveKit room.

Prompts are built by a pipeline, not typed — durable characters and scenes splice in verbatim, reference images carry roles, and every degradation the model forces is written into the trace. Edit, re-run a recipe, or composite a contact sheet.

A campaign shot in one scripted run: one model and one product held across five locations, a catalog matrix, recipe replay and a style swap — each frame shown with the prompt that made it and what it cost.

Give the agent continuity libraries, timed beats, first-frame references, provider-neutral jobs, resumable multi-shot flows, and a reviewer that watches the actual result before anything ships.

One brief becomes a keyframe, continuity definitions, a timed recipe, provider jobs, review evidence, and one approved cut. See the rejected work and the gate that keeps it off the page.

Five sibling subsystems — an entity graph, episodic timeline, resource filesystem, ambient context, and conversational forms — each with a focused tool surface and bring-your-own storage.

Expose capabilities as a relational database. The model discovers, invokes, and composes tools by writing SQL through a single execute_sql tool — with transactions as a real dry-run.

A persistent mailbox for what can't resolve now. The agent posts a request; a webhook, cron, or human resolves it later — and it's injected on the next turn, across restarts.

A persistent virtual filesystem the agent works in — writes scripts, runs them, inspects intermediates, iterates. No network, no host fs, no process; only the capabilities you inject.

Fifty tool definitions become one sandboxed REPL — JavaScript, Python or Lisp over the same catalog. The model composes and branches in a single call, and only the answer enters its context.

Make that boundary a privacy boundary: programs must end in a bounded decision, a bit budget caps cumulative disclosure, and a meter reports exactly what crossed.

Typed yes/no, choice and score answers from TypeSafe's Jev or open models you host (Kev, Laya, Von…), with confidence. Triage an inbox, a page or an inbound event in one parallel pass, and only the answers reach the agent.

Agents message each other — direct, broadcast, acknowledge — over a pluggable transport, riding the same inbox primitive. A planner and its workers, or a swarm of specialists.

Supervise agents as subprocesses. Triggered agents wake cold per event and resume a persistent store; concurrent agents stay warm and are notified inline.

Hooks mutate agent state before a turn, skills inject context, and subagents route self-contained work to isolated children — the /command and @mention surface.

Bridge Model Context Protocol servers — Notion, Gmail, Linear — in as first-class tools. A discovery subagent finds and activates them mid-conversation.

Maintain an existing sandboxed container deployment while you migrate. Glovebox is deprecated; build new agent applications, working environments, and deployment systems with Foundry.