Agents that do the work.
Glove is the open-source TypeScript stack for building AI agents: tools, memory, voice, UI, browsers and sandboxes. Foundry runs them as typed, observable services.
npx glove-foundry initThree ways in.
Every package works on its own. Start where your project is.
Glove Foundry
One TypeScript file per agent. Foundry adds persisted instances and conversations, an HTTP and OpenAI-compatible API, schedules, webhooks, approvals and an inspector.
npx glove-foundry initStart with Foundry glove-core
The agent loop, any model, Zod-validated tools and a display stack that renders React UI mid-conversation, in your Next.js or Node app.
pnpm add glove-core glove-reactQuickstart A single package
Memory, voice, browsers, sandboxes, MCP, image and video workflows. Each package mounts onto an agent you already have.
pnpm add glove-memoryBrowse packages Define it in code. Run it as data.
A definition says what an agent can be. Each instance stores what one live agent has: its context, installed apps and schedules. Foundry assembles the right model, tools and memory for every message, and shows you how the work happened.
- Codeagents/support/agent.tsa file-routed definition
- Datasupport-acmean instance with its own installs
- RunPOST /v1/chat/completionsassembled per message, traced
Everything an agent needs to finish the job.
Interfaces, memory, compute, media and coordination, as packages that mount onto the same runtime.
Foundry
Agent systems as a running service
Browsers & sandboxes
Browse, build and run
Interfaces
How people reach the agent
Memory & state
What it knows and carries forward
Compute
Somewhere to do the work
Generative media
Images and video you can inspect
Coordination
Agents working together
Extend & integrate
Shape it, connect it
A model, a tool, and you're running.
Tools are Zod-validated functions. They can render UI in the middle of a conversation and wait for the person to answer.
- Any model. Anthropic, OpenAI, Gemini, OpenRouter, Bedrock, Vercel AI Gateway, Ollama.
- Any store. A small adapter interface over whatever you already run.
- Tools that render.
pushAndForgetshows UI;pushAndWaitpauses until it's answered.
import { Glove, Displaymanager, createAdapter } from "glove-core";
import { z } from "zod";
const agent = new Glove({
model: createAdapter({ provider: "anthropic" }),
displayManager: new Displaymanager(),
systemPrompt: "You help people find running shoes.",
compaction_config: { compaction_instructions: "Keep the shopper's preferences." },
})
.fold({
name: "search_products",
description: "Search the product catalog",
inputSchema: z.object({ query: z.string() }),
async do(input, display) {
const hits = await catalog.search(input.query);
await display.pushAndForget({ renderer: "product_grid", input: hits });
return { status: "success", data: hits };
},
})
.build();
await agent.processRequest("Running shoes under $100");Five parts. Every one swappable.
The runtime talks to models, stores, displays and subscribers through adapters, so you can change any of them without touching your agent.
- 01Agent
The loop: prompt, call tools, feed results back.
- 02Prompt machine
Wraps the model behind a ModelAdapter.
- 03Executor
Validates, retries and permission-checks tools.
- 04Observer
Tracks turns and tokens; compacts long sessions.
- 05Display manager
The UI stack your tools render into.
Build something that works while you don't.
Open source, MIT licensed, ready to build on.