Anvia is an open, TypeScript agent stack that gives developers everything they need to build production agents — without taking ownership of their stack.
Your application stays the system of record: it creates the provider models, typed tools, memory stores, and observers, and passes them into Anvia agents and runners. Anvia runs the model/tool loop — remove it and you keep your product.
Why Anvia
- Provider-neutral clients for OpenAI-compatible APIs, Anthropic, Gemini, and Mistral — your agent architecture should not belong to your model provider.
- Agent and tool APIs that keep application behavior explicit and typed.
- Memory contracts for agent state and history, stored where you decide.
- Embeddable runtime contracts that keep provider, memory, observability, storage, and service choices in application code.
- Structured extraction and output schemas for turning model responses into usable data.
- Pipeline primitives for composing functions, agents, extractors, batches, and parallel branches.
- Retrieval adapters for in-memory search, local embeddings, ChromaDB, LanceDB, Milvus, pgvector, Pinecone, Qdrant, Redis, and Weaviate.
- Browser automation and sandboxed execution, so agents can act on the world and run work in environments you control.
- Evaluation primitives for scoring and regression-testing agent behavior on your infrastructure.
- Optional Studio, Lens, MCP, local skills, Langfuse, and OpenTelemetry integrations.
Anvia is an agent stack, not an agent platform. A platform asks you to build inside its system; a stack gives you components to build inside your own. If you are building an AI product you expect to own for years, ownership becomes part of the architecture.
Quick Start
Install the core runtime and a provider adapter:
pnpm add @anvia/core@latest @anvia/openai@latest
Create a provider client, construct an agent, and run it from your app:
import { Agent } from "@anvia/core";
import { OpenAIClient } from "@anvia/openai";
const client = new OpenAIClient({ apiKey });
const model = client.completionModel({ modelId: "gpt-5.5", api: "responses" });
const supportAgent = new Agent({
id: "support",
model: model,
instructions: "Answer support questions clearly. Ask for missing details.",
});
const response = await supportAgent.generate({
prompt: "A customer cannot reset their password. What should I check first?",
});
if (response.type !== "response") {
throw new Error(`Agent returned ${response.type}`);
}
console.log(response.output);
Use the same runtime shape with other providers:
pnpm add @anvia/anthropic@latest @anvia/gemini@latest @anvia/mistral@latest
Anvia clients take explicit constructor values and do not read environment variables on their own, so credentials stay in your existing configuration layer.
Studio
Anvia includes @anvia/studio, a local browser UI for inspecting and running agents, tools, sessions, traces, pipelines, memory, status, and knowledge during development.
Studio connects to the actual agent instance your application creates. Your model, instructions, tools, middleware, memory, and policies remain application code — one agent, one source of truth. Inspect, test, intervene, and replay against the running agent, then ship it unchanged.
Add one line to serve any agent in Studio:
new Studio([agent]).start({ port: 4021 });
What You Can Build
| Capability | Use it for |
|---|
| Agents | Model workflows with instructions, context, tools, lifecycle callbacks, memory, approvals, and streaming. |
| Tools | Safe, typed access to application-owned actions such as lookup, search, mutation, approval, or dispatch. |
| Extractors | Schema-shaped data from text, tickets, documents, messages, and model responses. |
| Pipelines | Explicit multi-step workflows that combine functions, agents, extraction, branching, and batching. |
| Retrieval | Embeddings, vector search, document context, metadata filters, and RAG workflows. |
| Memory | Agent memory using storage you control. |
| Durable | Experimental SQLite-backed agent recovery, persisted approvals, and reconnectable progress. |
| Browser | Web interaction for agents, with the browser lifecycle owned by your application. |
| Sandbox | Give agents execution capabilities without giving up control of the environment. |
| Observability | Run, generation, tool, usage, trace, and eval events for production visibility. |
| Evaluation | Score and regression-test agent behavior with evals that run on your infrastructure. |
| Studio | A local browser UI for inspecting agents, sessions, traces, pipelines, tools, approvals, and knowledge. |
| Lens | Observe and evaluate production agents on infrastructure you control. |
Cookbook
The cookbook is the fastest way to see Anvia in motion. It walks from a first text call through tools, structured output, providers, multimodal inputs, pipelines, retrieval, multi-agent workflows, evals, Studio, and integrations.
Run the first example from the repository root:
pnpm install
pnpm cookbook:basics:01
Run Studio locally:
pnpm cookbook:studio:01
Learn More
License
MIT
Anvia is free and open source. Build agents with your preferred model providers, keep your data in your own databases, run locally, self-host, and deploy without an Anvia account.
