All Packages

pnpm add glove-core zod

import { Glove, MemoryStore, Displaymanager, createAdapter } from "glove-core";
import { z } from "zod";

export const agent = new Glove({
  store: new MemoryStore("session-1"),
  model: createAdapter({ provider: "anthropic", model: "claude-sonnet-4-20250514" }),
  displayManager: new Displaymanager(),
  systemPrompt: "You are a helpful assistant.",
  compaction_config: { compaction_instructions: "Summarize the conversation so far." },
})
  .fold({
    name: "get_weather",
    description: "Get current weather for a city",
    inputSchema: z.object({ city: z.string() }),
    async do(input) {
      return { status: "success", data: await weather.lookup(input.city) };
    },
  })
  .build();

await agent.processRequest("What's the weather in Tokyo?");

pnpm add glove-react zod

"use client";
import { useGlove, Render } from "glove-react";

export function Chat() {
  const glove = useGlove();
  return <Render glove={glove} renderMessage={({ entry }) => <p>{entry.text}</p>} />;
}

pnpm add glove-next

import { createChatHandler } from "glove-next";

export const POST = createChatHandler({
  provider: "anthropic",
  model: "claude-sonnet-4-20250514",
  cache: true,
});

pnpm add glove-voice

import { createElevenLabsAdapters } from "glove-voice";
import { useGloveVoice } from "glove-react/voice";

const { stt, createTTS } = createElevenLabsAdapters({
  // Tokens are minted server-side — the API key never reaches the browser.
  getSTTToken: () => fetch("/api/voice/stt-token").then(r => r.json()).then(d => d.token),
  getTTSToken: () => fetch("/api/voice/tts-token").then(r => r.json()).then(d => d.token),
  voiceId: "JBFqnCBsd6RMkjVDRZzb",
});

const { runnable } = useGlove({ tools, sessionId });
const voice = useGloveVoice({ runnable, voice: { stt, createTTS } });
// voice.mode: "idle" | "listening" | "thinking" | "speaking"

pnpm add glove-voice-native

import { withNativeAudio } from "glove-voice-native";
import { SileroVADNativeAdapter } from "glove-voice-native/silero-vad";

const vad = new SileroVADNativeAdapter();
await vad.init();

const voice = useGloveVoice({
  runnable,
  voice: withNativeAudio({ stt, createTTS, vad }),
});

pnpm add glove-voice-s2s

import { RealtimeAgent, createS2SAdapter } from "glove-voice-s2s";

// Provider/model/credentials from args, falling back to S2S_* env vars.
const adapter = createS2SAdapter({ provider: "openai" });

const rt = new RealtimeAgent({ agent, adapter });
await rt.start();

// Push a result in from elsewhere and have the agent speak about it.
rt.inject("The order shipped.", { respond: true });

pnpm add glove-voice-avatar

import { TavusEchoAdapter, attachAvatar } from "glove-voice-avatar";

const avatar = new TavusEchoAdapter({
  apiKey: process.env.TAVUS_API_KEY!,   // server-side only
  faceId: process.env.TAVUS_FACE_ID!,
  // palId omitted → a minimal echo PAL is ensured, so the ONLY voice is the agent's.
  sendInteraction: (event) => duct.send({ t: "avatar_interaction", event }),
});

const detach = await attachAvatar(rt, avatar);
avatar.view; // { kind: "webrtc-room", url: … } — hand this to the client

pnpm add glove-voice-livekit

import { LiveKitTransport, attachRealtime, mintParticipantToken } from "glove-voice-livekit";

const transport = new LiveKitTransport({
  url: process.env.LIVEKIT_URL!,
  token: await mintParticipantToken(
    { apiKey: process.env.LIVEKIT_API_KEY!, apiSecret: process.env.LIVEKIT_API_SECRET! },
    { roomName: "call-42", identity: "agent" },
  ),
});

await transport.connect();
attachRealtime(rt, transport);   // mics → model, model → track, interrupt → flush
await rt.start();

pnpm add glove-memory

import {
  useMemoryReader, useEpisodicReader, useContext,
  InMemoryEntityAdapter, InMemoryEpisodicAdapter, InMemoryContextAdapter,
} from "glove-memory";

// Reference in-memory adapters ship for dev/test; implement the contracts
// (EntityMemoryAdapter, EpisodicMemoryAdapter, …) against your own storage.
const entities = new InMemoryEntityAdapter({ schema: ontology });

useMemoryReader(agent, entities);                      // read-only entity tools
useEpisodicReader(agent, new InMemoryEpisodicAdapter());
useContext(agent, new InMemoryContextAdapter());       // injected every turn

// Writes belong to a separate curator instance:
// useMemoryCurator(curator, entities);

import { FormRegistry } from "glove-memory/forms";
import { useFormRunner, InMemoryFormAdapter } from "glove-memory";

const registry = new FormRegistry().register("travel-claim", {
  name: "Travel reimbursement claim",
  description: "Claimant, trip, travel and approval details.",
  load: () => import("./forms/travel-claim").then((m) => m.travelClaim),
});

// Folds seven glove_form_* tools and injects the one-line tier-0 status
// into the system prompt each turn.
const { runner } = useFormRunner(agent, new InMemoryFormAdapter({ schema }), {
  registry,
  subject: conversationId,
});

pnpm add glove-scratchpad

import { Database, defineResource, mountDatabase } from "glove-scratchpad";
import { z } from "zod";

const db = await Database.create({ policy: { writes: true } });

db.register(defineResource({
  name: "github_pull_requests",
  volatility: "volatile",
  schema: z.object({
    number: z.number().int(),
    title: z.string(),
    state: z.string().describe("open | merged | closed"),
  }),
  keys: ["number"],
  // WHERE state = 'open' arrives as a binding — an argument, not a post-filter.
  select: (b) => github.listPRs({ state: b.one("state") }),
}));

mountDatabase(agent, { db });   // folds execute_sql + explain_sql, primes the prompt

pnpm add glove-sql

import { MemoryBackend } from "glove-sql";

const be = await MemoryBackend.create();
await be.exec(`CREATE TABLE orders (id int, total numeric, region text)`);
await be.exec(`INSERT INTO orders VALUES (1, 42.00, 'emea')`);

const { rows } = await be.query(
  `SELECT region, sum(total) AS revenue FROM orders GROUP BY region`,
);

const bytes = await be.dump();   // serialise the whole database

pnpm add glove-working-environment

import { createWorkingEnvironment, mountWorkingEnvironment } from "glove-working-environment";
import { spreadsheets } from "glove-env-spreadsheets";

const env = await createWorkingEnvironment({
  stdlib: [spreadsheets()],
  limits: { runTimeoutMs: 30_000 },
});

await env.mount("./q3.xlsx", "/inbox/q3.xlsx");   // host-side door
mountWorkingEnvironment(agent, { env });          // model-facing verbs + preamble

const deliverables = await env.export("/out/**"); // → [{ path, bytes }]

import { documents } from "glove-env-documents";
import { images } from "glove-env-images";

const env = await createWorkingEnvironment({ stdlib: [documents(), images()] });

pnpm add glove-js glove-scratchpad

import { JsSession, mountJs } from "glove-js";
import { fnsFromMcp } from "glove-scratchpad/fns/mcp";

const session = JsSession.create();
session.registerAll(await fnsFromMcp(githubConn));  // github__list_pull_requests, …

mountJs(agent, { session });

pnpm add glove-python glove-scratchpad

import { PySession, mountPy } from "glove-python";

const session = PySession.create();
session.registerAll(await fnsFromMcp(githubConn));

mountPy(agent, { session });

pnpm add glove-lisp glove-scratchpad

;; What the model writes inside execute_lisp
(def prs (github_pull_requests {:state "open"}))   ; 320 rows stay in the REPL
(if (empty? (pagerduty_incidents {:urgency "high"}))
  (insert! :slack_messages {:channel "ops" :text "All clear."})
  (insert! :emails {:to_addr "oncall@acme.io" :subject "Incidents live"}))

pnpm add glove-egress

import { egressFns, guardEffectFns, DEFAULT_EGRESS_POLICY, BoundaryMeter } from "glove-egress";

session.registerAll(egressFns(DEFAULT_EGRESS_POLICY));  // assert/count/choose/bucket/report
const guarded = guardEffectFns(catalog, DEFAULT_EGRESS_POLICY, onBlock);

const meter = new BoundaryMeter();
meter.cross("assertion", true, { decisionSpace: 2 });
meter.report(canaries);  // what actually crossed

pnpm add glove-image

import {
  mountImage,
  InMemoryImageAssetStore,
  InMemoryImageLibrary,
  expandCharacters,
  expandScenes,
  styleDirective,
  openrouterImages,
} from "glove-image";

await mountImage(glove, {
  adapter: openrouterImages(),               // OPENROUTER_API_KEY
  assets: new InMemoryImageAssetStore(),
  library: new InMemoryImageLibrary(),
  pipeline: [expandCharacters(), expandScenes(), styleDirective("gouache, muted palette")],
});

// The agent then works in asset ids:
//   glove_image_character_save({ name: "mira", appearance: "..." })
//   glove_image_generate({ intent: "Mira at the harbor", characters: ["mira"] })
//   glove_image_regenerate({ asset: "img_...", tweak: "at dusk" })

pnpm add glove-mesh

import { mountMesh, MeshNetwork, InMemoryMeshAdapter } from "glove-mesh";

const network = new MeshNetwork();

await mountMesh(planner, {
  adapter: new InMemoryMeshAdapter(network),
  identity: {
    id: "planner",
    name: "Planner",
    description: "Breaks work down and hands it to specialists.",
    capabilities: ["planning"],
  },
});

// Folds glove_mesh_send_message / _broadcast / _list_agents / _acknowledge.
// Inbound messages land in this agent's inbox and surface on its next turn —
// so the store must support the inbox methods.

pnpm add glove-continuum-signal

import { agent, z, ContinuumRunner, MemoryAdapter } from "glove-continuum-signal";

export const pizzaBaker = agent("pizza-baker")
  .input(z.object({ orderId: z.string() }))
  .triggered()
  .timeout(60_000)
  .retries(2)
  .every("5m").withInput({ orderId: "tick" })
  .factory(async (ctx) => buildGlove(ctx));

const runner = new ContinuumRunner({ adapter: new MemoryAdapter() });
runner.registerAgent(pizzaBaker, import.meta.url);
await runner.start();

pnpm add glove-mcp

import { mountMcp } from "glove-mcp";

await mountMcp(runnable, {
  adapter: myAdapter,          // getActive / activate / deactivate / getAccessToken
  entries: [{
    id: "notion",
    name: "Notion",
    description: "Search, read, and edit pages in a Notion workspace.",
    url: "https://mcp.notion.com/mcp",
    tags: ["docs", "notes", "wiki"],
  }],
  clientInfo: { name: "my-app", version: "1.0.0" },
});