What is Glove?

Glove is an open-source TypeScript framework for building applications where an AI agent drives the app. You define capabilities as tools. The agent decides which ones to call, in what order, and renders the results — as text, as UI, or as speech.

It is not a chatbot SDK. The runtime ships a display stack, a persistent inbox, a memory layer, a mesh for agents to talk over, sandboxes for the model to compute in, and a packaging story for deployment. Every piece is a separate package you can adopt on its own.

The core idea

Traditional apps encode user flows in UI — pages, routes, navigation hierarchies, state machines. Glove replaces that wiring with an agent loop:

what a session looks liketext

User: "Find me running shoes under $100"
  → agent calls search_products  → pushes a product grid onto the display stack

User: "Add the Nike ones to my cart and check out"
  → agent calls add_to_cart      → returns the updated cart
  → agent calls checkout         → pushes a payment form and WAITS for the user
  → the tool resumes with the submitted payment and creates the order

You never wrote a route, a wizard, or a step counter. You wrote three tools and let the model sequence them.

Key terms

Five words carry most of the framework. Each has a page of its own; this is the one-line version.

Term	What it is
Tool	A capability: a name, a description, a Zod input schema, and an async `do()`. Registered with `fold()`.
Agent loop	Prompt the model → run the tools it asks for → feed results back → repeat until it answers with text.
Display stack	What the user sees. Tools push components onto it — `pushAndForget` to show, `pushAndWait` to pause the tool until the user responds.
Store	Where the conversation lives. In-memory, SQLite, your own backend — anything implementing `StoreAdapter`.
Adapter	The seam at every layer: model, store, display, subscriber, voice. Swap the implementation, keep the app.

What you can build

Commerce and booking flows — search, cart, checkout, confirmation dialogs rendered inline by the tools that need them.
Voice-first products — the same tools, spoken: cascade (STT → agent → TTS), realtime speech-to-speech, or a live avatar in a LiveKit room.
Back-office and analyst agents — a sandboxed working environment where the agent writes scripts, produces spreadsheets and PDFs, and hands back artifacts.
Operations agents over many services — dozens of MCP servers folded behind one SQL or code-eval tool instead of a hundred tool definitions.
Multi-agent systems — a planner and its workers, messaging over the mesh, supervised as subprocesses.

How it fits together

One runtime, five components, and a set of packages that plug into it.

architecturetext

your tools ─┐
              ▼
┌──────────────────────────────────────────────────────────┐
│  Agent          the agentic loop                         │
│  PromptMachine  model wrapper + system prompt            │
│  Executor       tool runner (Zod validation, retries)    │
│  Observer       turns, tokens, context compaction        │
│  DisplayManager the UI state machine                     │
└──────────────────────────────────────────────────────────┘
      ▼                ▼               ▼            ▼
 ModelAdapter    StoreAdapter   DisplayManager   Subscriber
 (any LLM)       (any DB)       (any UI layer)   (any sink)

Where to go next

Step 1Installation

Pick the packages your app shape needs, set a provider key, and you are running.

Step 2Quickstart

A working agent with a real tool in 15 minutes — full-stack or server-only.

Step 3Core Concepts

The agent loop, tools, the display stack and compaction, explained properly.

ReferenceAll Packages

Every package Glove ships, what it solves, and the smallest snippet that uses it.