v4Live context, Foundry & new guides

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 init
Used in production byProximaOrigin

Three ways in.

Every package works on its own. Start where your project is.

Glove Foundry

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.

  1. Codeagents/support/agent.tsa file-routed definition
  2. Datasupport-acmean instance with its own installs
  3. 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.

Browsers & sandboxes

Browse, build and run

Memory & state

What it knows and carries forward

Generative media

Images and video you can inspect

Coordination

Agents working together

Extend & integrate

Shape it, connect it

In your app

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. pushAndForget shows UI; pushAndWait pauses until it's answered.
agent.tstypescript
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.

  1. 01Agent

    The loop: prompt, call tools, feed results back.

  2. 02Prompt machine

    Wraps the model behind a ModelAdapter.

  3. 03Executor

    Validates, retries and permission-checks tools.

  4. 04Observer

    Tracks turns and tokens; compacts long sessions.

  5. 05Display manager

    The UI stack your tools render into.

How the runtime fits together

Build something that works while you don't.

Open source, MIT licensed, ready to build on.

ElevenLabs Startup Grant