# Glove

> Glove is an open-source TypeScript stack for software that an AI agent operates. glove-core is the agent loop (tools with Zod schemas, a display stack that renders UI mid-conversation, stores, model adapters). Independent capability packages add memory, forms, goals, working environments, JS/Python/Lisp REPLs, browsers and sandboxes, MCP, voice, realtime speech-to-speech, image and video workflows, classifiers and agent mesh. Glove Foundry (glove-foundry) is the application framework that runs agents as a service: file-routed definitions, persisted instances and conversations, a typed client, REST and OpenAI-compatible APIs, schedules, inbound integrations, approvals and an inspector.

## Start here

- [Choose your path](https://glove.dterminal.net/docs): Foundry vs glove-core vs a single package, plus an I-want-to index.
- [Glove Foundry overview](https://glove.dterminal.net/foundry/docs): what Foundry provides out of the box.
- [Foundry tutorial](https://glove.dterminal.net/foundry/docs/tutorial): a complete multi-tenant support agent, step by step.
- [Glove quickstart](https://glove.dterminal.net/docs/getting-started): an agent inside a Next.js or Node app.
- [All packages](https://glove.dterminal.net/docs/packages): every package and its smallest snippet.
- [Goal-oriented agents](https://glove.dterminal.net/docs/goal-oriented-agents): when to use tools, context, facts, forms, goals or a UI form to collect information, with a worked booking agent.
- [Voice agent architectures](https://glove.dterminal.net/docs/voice-architectures): single-agent vs layered voice, realtime vs pipeline fronts, <speech> tags and fast front models.
- [Foundry index](https://glove.dterminal.net/foundry/llms.txt) and [Foundry full reference](https://glove.dterminal.net/foundry/llms-full.txt)
- [Glove full reference](https://glove.dterminal.net/llms-full.txt)
- Agent skills for coding agents: https://github.com/porkytheblack/glove/tree/main/.claude/skills
- Repository: https://github.com/porkytheblack/glove

## Key facts

- Everything is TypeScript + ESM. Tool inputs are Zod schemas. Every layer (model, store, display, subscriber, voice) is an adapter interface.
- Packages are independent: install glove-core plus only what you need. Foundry is optional and builds on the same agents and tools.
- In Foundry, composeAgent(...) only makes shared tools, apps and MCP servers available; an instance must install() them before they mount. Always-on tools go in defineAgent's tools field.
- Foundry's /v1/chat/completions and /v1/responses accept an agent instance id (or a definition route with exactly one instance) as `model`; reuse `user`, `conversation_id` or the x-foundry-conversation-id header to continue a conversation.
- Each Foundry run executes in its own process: a store that returns a plain MemoryStore forgets earlier turns. Give agents a durable store (the starter templates ship lib/file-store.ts) — see /foundry/docs/persistence.
- Dynamic goals are exported by glove-memory/goals (glove-memory 1.2.0+); there is no glove-goals package. Shared evidence is glove-facts (0.1.0+).
- With glove-core 4.0+, goals, forms and pinned context are live runtime snapshots appended at the model-input tail; system instructions and saved history are not rewritten. Runnable proxies forward addContextProvider and getRuntimeContext.
- Forms support opt-in skippable: true and runner.skip(field, reason), exposed as glove_form_revise action=skip.
- Forms do not settle goals: call goals.update from a form step or checkpoint executor. record_fact only records unverified text; actions and outcomes need verified evidence recorded by host code.
- GloveVoice speaks every text_delta sentence by sentence; <speech> tag filtering is an example-level parser (examples/layered-voice speech-parser.ts), not a glove-voice option. Layered voice puts a fast front model on every turn and delegates tool work to a heavy worker over glove-mesh.
- glove-execution mounts browser scripts (execute_browser) and persistent sandboxes (execute_sandbox) onto existing agents without replacing their model. Station 3 is the first backend; Foundry can host providers via stationDaemon from glove-foundry/station.
- glove-classifier adds structured-decision models (TypeSafe's Jev, open System One models, zero-shot scorers). Jev is not a chat model; never pass it to createAdapter.
- glove-core ships a vercel provider (Vercel AI Gateway) that reads AI_GATEWAY_API_KEY, falling back to VERCEL_OIDC_TOKEN.

## Start Here

What Glove is, how to install it, and a tour of every package.

- [Choose your path](https://glove.dterminal.net/docs): Start here: Foundry for complete agent systems, glove-core for an agent inside your app, or one capability package — plus an I-want-to index.
- [What is Glove?](https://glove.dterminal.net/docs/intro): The idea behind Glove: define capabilities as tools, let an agent orchestrate them.
- [Glove Foundry](https://glove.dterminal.net/foundry): The file-routed, Effect-native framework for assembling, running, and inspecting complete agent systems. [glove-foundry]
- [Installation](https://glove.dterminal.net/docs/installation): Which packages to install for which shape of app, model providers, and environment variables. [glove-core, glove-react, glove-next]
- [Quickstart](https://glove.dterminal.net/docs/getting-started): Build a working agent in 15 minutes — full-stack (Next.js + React) and server-only paths. [glove-core, glove-react, glove-next]
- [Core Concepts](https://glove.dterminal.net/docs/concepts): The agent loop, tools, the display stack, stores, adapters and context compaction.
- [All Packages](https://glove.dterminal.net/docs/packages): Every package Glove ships, what it is for, and the smallest snippet that uses it.

## Building Agents

The runtime surface you write against every day.

- [The Display Stack](https://glove.dterminal.net/docs/display-stack): Tools push UI mid-conversation — pushAndWait, pushAndForget, display strategies. [glove-core, glove-react]
- [Hooks, Skills & Subagents](https://glove.dterminal.net/docs/extensions): Mutate state before a turn, inject context on demand, and route work to isolated children. [glove-core]
- [The Inbox](https://glove.dterminal.net/docs/inbox): A persistent mailbox for work that cannot resolve now — resolved later, injected next turn. [glove-core]
- [Classifier Models](https://glove.dterminal.net/docs/classifier): Fast, calibrated typed decisions — TypeSafe's Jev or any classifier — as agent tools, with an LLM fallback and confidence-gated cascades. [glove-classifier]
- [Server-Side Agents](https://glove.dterminal.net/docs/server-side): CLI tools, backend services and WebSocket servers with no React in sight. [glove-core]
- [Core API Reference](https://glove.dterminal.net/docs/core): Glove, Agent, PromptMachine, Executor, Observer, DisplayManager and every adapter contract. [glove-core]

## Interfaces

How people reach the agent — rendered UI, speech, and a live face.

- [React](https://glove.dterminal.net/docs/react): GloveClient, GloveProvider, useGlove, <Render>, defineTool and the client bindings. [glove-react]
- [Next.js](https://glove.dterminal.net/docs/next): createChatHandler — SSE streaming route handlers for the App Router. [glove-next]
- [Voice Agent Architectures](https://glove.dterminal.net/docs/voice-architectures): Pipeline vs realtime, single vs layered: a fast front agent that talks while a worker thinks, and <speech> tags for streaming only what should be said. [glove-voice, glove-voice-s2s, glove-mesh]
- [Voice Pipeline](https://glove.dterminal.net/docs/voice): The cascade — VAD → STT → agent → TTS — with barge-in, push-to-talk and React Native. [glove-voice, glove-voice-native]
- [Realtime Voice & Avatars](https://glove.dterminal.net/docs/realtime-voice): Speech-to-speech models, live avatars, and LiveKit as the room transport. [glove-voice-s2s, glove-voice-avatar, glove-voice-livekit]

## Generative Media

Agentic image and video generation — workflows, not one-off calls.

- [Image Workflows](https://glove.dterminal.net/docs/image): Prompt pipelines with enhancer inbetweens, durable characters and scenes, reference images, editing, assembly, vision review and per-call cost tracking. [glove-image]
- [Image Gallery](https://glove.dterminal.net/docs/image/gallery): A worked SS26 campaign — every image with its real prompt, pipeline trace and cost, plus a provenance canvas showing how one was made. [glove-image]
- [Video Workflows](https://glove.dterminal.net/docs/video): Temporal prompt pipelines, continuity libraries, image references, actual-video review, delivery gates, resumable flows and spend tracking. [glove-video, glove-image]
- [Video Gallery](https://glove.dterminal.net/docs/video/gallery): An agent-directed case study exposing the keyframe, timed recipe, every reviewed take, revision evidence, delivery decision and real spend. [glove-video, glove-image]

## Memory & State

What the agent knows, and what it carries between turns.

- [Memory](https://glove.dterminal.net/docs/memory): Entity graph, episodic timeline, resource filesystem and ambient context — BYO storage. [glove-memory]
- [Goal-Oriented Agents](https://glove.dterminal.net/docs/goal-oriented-agents): When to use goals, forms, facts, memory context or a UI form to collect information — and a complete agent that pursues an objective, gathers what is missing, then acts. [glove-memory, glove-facts]
- [Forms](https://glove.dterminal.net/docs/forms): Structured collection over a conversation — Zod-authored definitions, lazily loaded, with colocated executors. [glove-memory]
- [Dynamic goals](https://glove.dterminal.net/docs/goals): Context-sensitive goal programs, checklist progress, revision history, and deferred follow-ups — BYO storage. [glove-memory]
- [Shared facts](https://glove.dterminal.net/docs/facts): Scoped evidence and preparation through a supplied Glove agent, shared by goals and forms. [glove-facts, glove-memory]
- [Why Memory](https://glove.dterminal.net/docs/memory/why): The design story behind the four-primitive split.
- [Scratchpad](https://glove.dterminal.net/docs/scratchpad): Expose tools as a relational database the model queries with one execute_sql tool. [glove-scratchpad]
- [SQL Engine](https://glove.dterminal.net/docs/sql): The zero-dependency Postgres-subset engine behind the scratchpad. [glove-sql]

## Sandboxes & Execution

Give the model a place to compute instead of a wall of tool definitions.

- [Browsers & Sandboxes](https://glove.dterminal.net/docs/execution): Mounted browser workflows, persistent coding sandboxes, and optional shared Station hosting in Foundry. [glove-execution, glove-foundry]
- [Virtual Filesystem](https://glove.dterminal.net/docs/vfs): One tree the working environment, memory resources and the REPLs all share — mounts, access policies, metadata and search. [glove-vfs]
- [Working Environment](https://glove.dterminal.net/docs/working-environment): A persistent sandboxed virtual filesystem — write scripts, run them, iterate, export artifacts. [glove-working-environment, glove-vfs, glove-env-documents, glove-env-spreadsheets, glove-env-images, glove-env-slides, glove-env-zip, glove-env-media, glove-env-fetch, glove-env-secret]
- [Code Execution](https://glove.dterminal.net/docs/code-execution): One eval tool instead of fifty tool definitions — JavaScript, Python and Lisp REPLs. [glove-js, glove-python, glove-lisp]
- [Egress Control](https://glove.dterminal.net/docs/egress): Make the sandbox boundary a measured, enforced privacy boundary. [glove-egress]

## Multi-Agent

Many agents, coordinated.

- [Mesh](https://glove.dterminal.net/docs/mesh): Direct, broadcast and acknowledged messaging between agents over a pluggable transport. [glove-mesh]
- [Continuum](https://glove.dterminal.net/docs/continuum): Supervise agents as subprocesses — triggered (cold) and concurrent (warm) modes. [glove-continuum-signal]

## Integrate

Reach the outside world. To deploy, see the Foundry deploy guide.

- [MCP](https://glove.dterminal.net/docs/mcp): Bridge Model Context Protocol servers in as first-class tools, with a discovery subagent. [glove-mcp]

## Showcase

Complete applications, read end to end.

- [All examples](https://glove.dterminal.net/docs/showcase): Every runnable example and walkthrough — Foundry systems, display-stack apps, voice agents, sandboxes and media studios.
- [Travel Planner](https://glove.dterminal.net/docs/showcase/travel-planner): Build a trip planner whose tools render option pickers, itinerary cards and confirmations with the display stack. [glove-react, glove-next]
- [Coding Agent](https://glove.dterminal.net/docs/showcase/coding-agent): A coding agent with file tools, a WebSocket server, a React client and permission prompts before writes. [glove-core, glove-react]
- [Coffee Shop](https://glove.dterminal.net/docs/showcase/coffee-shop): A voice-first barista: product cards, a live shopping bag and checkout, ordered by speaking. [glove-react, glove-voice]
- [Lola](https://glove.dterminal.net/docs/showcase/lola): A voice movie companion that searches films and narrates while it renders poster grids. [glove-react, glove-voice]
- [Ecommerce Store](https://glove.dterminal.net/docs/showcase/ecommerce-store): A shopping assistant with product grids, size and colour pickers, a cart and checkout as tool-rendered UI. [glove-react, glove-next]
- [Terminal Agent](https://glove.dterminal.net/docs/showcase/terminal-agent): A server-only agent in the terminal with filesystem and shell tools and no React. [glove-core]

## Resources

Everything else.

- [Glove for LLMs](https://glove.dterminal.net/docs/llms): llms.txt, llms-full.txt and the Claude Code agent skill.
- [Agent Skill](https://glove.dterminal.net/docs/agent-skill): Install the Glove and Foundry skills so Claude Code and other coding agents write correct Glove code.
- [v4 Release Notes](https://glove.dterminal.net/docs/v4): What changed in glove-core 4.0 through 4.3: live runtime context, the 4.0 migration, and the 4.1–4.3 highlights. [glove-core]
- [v3.0.0 Release Notes](https://glove.dterminal.net/docs/v3): What changed in Glove v3 and how to upgrade.

## Glove Foundry handbook

- [Overview](https://glove.dterminal.net/foundry/docs): What Foundry gives you out of the box, when to use it instead of plain Glove, and the definition → instance → run model.
- [Install & CLI](https://glove.dterminal.net/foundry/docs/getting-started): The setup wizard, both starter templates, every CLI command and flag, and your first run in the inspector.
- [Tutorial: first agent system](https://glove.dterminal.net/foundry/docs/tutorial): Build a support agent step by step: a tool, an installed app, instances, conversations, a schedule, an approval, and an OpenAI SDK client.
- [Project structure](https://glove.dterminal.net/foundry/docs/project-structure): Every file convention, how filenames become ids, foundry.application.ts vs foundry.config.ts, generated route types and the ESLint preset.
- [Definitions & instances](https://glove.dterminal.net/foundry/docs/definitions-and-instances): What belongs in code, what belongs in data, how instances are created, updated and reconstructed, and where string ids are correct.
- [defineAgent & assembly](https://glove.dterminal.net/foundry/docs/composition): Every defineAgent field, the value-or-resolver rule, the assembly context, and configure/build/run lifecycle hooks.
- [Tools, MCP & memory](https://glove.dterminal.net/foundry/docs/capabilities): Always-on tools vs installable shared tools, MCP servers over HTTP or stdio, memory profiles, layers, subscribers, and typed calls.
- [Goals, facts & forms](https://glove.dterminal.net/foundry/docs/guidance): Guided conversations, durable evidence and answers, native preparation, and live context providers.
- [Apps & transmissions](https://glove.dterminal.net/foundry/docs/applications): Installable capability bundles, inbound and outbound transports, accounts, routes, connections, and the credential boundary.
- [Playbooks, schedules & sleep](https://glove.dterminal.net/foundry/docs/automation): Event-driven playbooks, subscriptions that provision agents, cron and interval schedules, sleep, spawn and the built-in agent tools.
- [Conversations & shared work](https://glove.dterminal.net/foundry/docs/conversations): Many conversations per instance, transcripts, workspace entries, the shared inbox, tasks, and scoped environment values.
- [Working environments](https://glove.dterminal.net/foundry/docs/working-environments): Mount a VFS, a REPL, programmatic tool calling, skills, and document or media adapters for artifact-producing agents.
- [Browser & sandbox agent](https://glove.dterminal.net/foundry/docs/browser-and-sandbox): A runnable personal agent with mounted browser scripts, persistent code sandboxes and managed servers on one Station.
- [Multi-agent systems](https://glove.dterminal.net/foundry/docs/multi-agent): Subagents with least-privilege tools, typed calls, spawn, mesh, voice hosts, and coordination through shared work.
- [Client & HTTP API](https://glove.dterminal.net/foundry/docs/runtime): The typed client, every native /api endpoint, the /v1/runs automation API, live event streams and health checks.
- [OpenAI-compatible API](https://glove.dterminal.net/foundry/docs/openai-compatible): Point any OpenAI SDK at Foundry: /v1/chat/completions and /v1/responses backed by durable instances and conversations.
- [Approvals & steering](https://glove.dterminal.net/foundry/docs/approvals): Human-in-the-loop: permission-gated tools become expiring approval records; redirect active work with interrupt-and-restart steering.
- [Inspector & WebChat](https://glove.dterminal.net/foundry/docs/observability): The built-in inspector, WebChat, run traces, keyboard shortcuts, the event envelope, and custom subscribers.
- [Persistence](https://glove.dterminal.net/foundry/docs/persistence): The four things to persist separately — runtime data, transcripts, memory and the VFS — with file, SQLite and custom adapters.
- [Next.js integration](https://glove.dterminal.net/foundry/docs/nextjs): Add Foundry to an existing Next.js app: the generated layout, the typed client, route handlers and FOUNDRY_URL.
- [Deploy & security](https://glove.dterminal.net/foundry/docs/deploy): Production checklist, request authorization, health checks, the managed execution daemon and scaling by role.
- [API reference](https://glove.dterminal.net/foundry/docs/reference): Every export of glove-foundry and its subpaths, the built-in agent tools, HTTP endpoints, CLI flags and config keys in one place.
- [FAQ & troubleshooting](https://glove.dterminal.net/foundry/docs/faq): Why a tool is missing, why state reset, why the server refuses to bind, and other questions people ask in their first week.

## Blog

- [Classifier models in Glove: decide what matters without reading it](https://glove.dterminal.net/blog/classifier-models): glove-classifier brings System One models like TypeSafe's Jev to agents, REPLs, working environments, browsers and Foundry. Measured on a labelled inbox: 85% less agent context, higher accuracy, and customer data kept out of the agent.
- [Agents with browsers, sandboxes, and one managed daemon](https://glove.dterminal.net/blog/agents-with-browsers-and-sandboxes): How glove-execution extends the Glove family through capability mounts, and how Foundry hosts jobs and resource adapters on one Station.
- [Conversations that keep their purpose](https://glove.dterminal.net/blog/conversations-that-keep-their-purpose): Goals, forms, and shared facts help conversational agents keep their objectives while people interrupt, answer early, and change their minds.
- [Fresh context belongs inside the agent loop](https://glove.dterminal.net/blog/fresh-context-in-the-agent-loop): How reusable context providers inject current application state before each model iteration, and why moving memory out of system prompts matters for caching.
- [Building video workflows with Glove](https://glove.dterminal.net/blog/building-video-workflows-with-glove): Use glove-video for reusable creative direction, resumable shot flows, actual-video review, and gated delivery.
- [The workflow is no longer the product](https://glove.dterminal.net/blog/introducing-glove-foundry): Introducing Glove Foundry: a file-routed, Effect-native application framework where agent systems are assembled from definitions and live instance data—and the work can be imagined at runtime.
- [Every failure in this one was silent](https://glove.dterminal.net/blog/silent-failures): Building video rendering for agents — plus a fourth way to expose a capability, a verb for handing work over, and directories an agent may read but never edit. Six bugs that reported success, and what each one changed about the design.
- [Glove from A to Z: Building agents from scratch](https://glove.dterminal.net/blog/glove-from-a-to-z): Start with a loop that calls a function, then add one piece at a time — only when something breaks. Every primitive in the framework, in the order it earns its place.
- [Shipping Forms](https://glove.dterminal.net/blog/shipping-forms): A collection primitive for conversations — the decisions behind it, and the five defects a fifty-cent agentic eval found that reading the code had not.
- [Building the voice stack: what only live calls told us](https://glove.dterminal.net/blog/building-the-voice-stack): Five examples, three avatar providers, and a run of bugs that every test suite passed through. Notes on the decisions that held and the ones the wire corrected.
- [A product is a character too](https://glove.dterminal.net/blog/a-product-is-a-character): What it takes to shoot the same model, carrying the same bag, in five places — and why agentic image generation is a workflow problem rather than a tool problem.
- [Eight new packages](https://glove.dterminal.net/blog/eight-new-packages): Realtime voice and avatars, agentic image generation, a working environment that can look at what it made, and memory that knows what to withhold.