Build agents that do cool things.
Glove is an open-source TypeScript framework for AI-powered applications. You define tools; the agent decides when to use them — then renders UI, speaks, remembers, computes in a sandbox, and coordinates with other agents.
Agents outgrew the chatbox, and need more.
An agent that only calls tools and prints text hits a wall fast. Glove gives it the rest — a way to render UI and speak, memory and a mailbox, a sandbox to compute in, peers to coordinate with, and a way to ship. Every one is a separate package you can adopt on its own.
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.
Four sibling subsystems — an entity graph, an episodic timeline, a resource filesystem, and ambient context — each an independent, bring-your-own-storage adapter with its own tool surface.
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.
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.
Package an agent as a sandboxed container with one authenticated WebSocket endpoint per session. Five base images, a storage policy for payloads, and a client SDK.
A tool, a model, and you're running.
Everything else is opt-in. Install the runtime, describe what your app can do, and let the agent sequence it.
import {
Glove, MemoryStore, Displaymanager, createAdapter,
} from "glove-core";
import { z } from "zod";
const agent = new Glove({
store: new MemoryStore("session-1"),
model: createAdapter({ provider: "anthropic" }),
displayManager: new Displaymanager(),
systemPrompt: "You are a helpful assistant.",
})
.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);
// Render a grid mid-conversation, keep going.
await display.pushAndForget({
renderer: "product_grid",
input: hits,
});
return hits;
},
})
.build();
await agent.processRequest("Running shoes under $100");glove-core is the runtime. Memory, sandboxes, voice, mesh and MCP are separate packages that mount onto it — nothing you skip costs you anything.
pushAndForget shows UI mid-run; pushAndWait suspends the tool until the user answers, then resumes with their value.
Anthropic, OpenAI, Gemini, OpenRouter, Bedrock, Ollama and LM Studio behind one factory — and a store interface small enough to implement over whatever you already run.
Five components. One runtime.
Built on adapters — interfaces that decouple the runtime from specific implementations. Swap models, stores, or UI frameworks without changing application logic.
Swap anything. Change nothing.
Every layer is an interface. The runtime doesn't care what's behind it.
ModelAdapter
The AI provider. Anthropic, OpenAI, local models, or mocks for testing. Anything that takes messages and returns responses.
StoreAdapter
The persistence layer. Messages, tokens, turns, inbox. In-memory, SQLite, Postgres — wherever your state lives.
DisplayManagerAdapter
The UI state layer. Manages the display stack. Framework-agnostic — React, Vue, Svelte, terminal UI. Bind however you want.
SubscriberAdapter
The event bus. Logging, analytics, real-time streaming, debugging. Plug in whatever you need to observe.
