> ## Documentation Index
> Fetch the complete documentation index at: https://docs.agentium.in/llms.txt
> Use this file to discover all available pages before exploring further.
# Introduction
> Agentium is a TypeScript-native agent orchestration framework for Node.js. Model-agnostic, multi-agent teams, workflows, RAG, and more.
# Introduction
## In one sentence
**Agentium is the toolkit for building AI assistants that actually work in the real world** — ones that remember your customers, take real actions, ask a human before doing anything risky, and don't blow your budget.
**New here? Read these three sections** ("In one sentence", "What problem it solves", "How to think about it") and you'll understand what Agentium is — no technical background needed. Everything after that is for the people who'll build with it.
## What problem it solves
Today's AI models (GPT, Claude, Gemini) are incredibly smart but have three real-world gaps:
1. **They forget.** Every conversation starts from zero — the model doesn't remember who you are.
2. **They can't act.** Out of the box, a model can only write text. It can't look up an order, issue a refund, or send an email.
3. **They're hard to trust in production.** No spending limits, no human approval for risky actions, no record of what they did.
Agentium fills all three gaps. It's the layer between the raw AI model and a real product — the part that turns "a clever chatbot" into "a reliable digital employee."
| You are a… | What Agentium means for you |
| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Business / CEO** | Ship AI features customers trust — with memory, spending controls, and human oversight built in. Less time and money than building it yourself. |
| **Product / CTO** | A production-grade foundation: memory, multi-agent teams, cost tracking, observability, voice, and browser automation — one TypeScript codebase, no paid add-ons. |
| **Developer** | Pure TypeScript. Swap models, storage, and transport with one line. Type-safe tools, batteries included, no Python runtime. |
## How to think about it
Imagine hiring a new employee. To be useful, they need more than intelligence:
* a **memory** of who they've talked to,
* **tools** to actually do their job (your systems, your APIs),
* **rules** about what they can and can't do without checking with a manager,
* and a **manager** watching costs and quality.
A raw AI model is just the intelligence. **Agentium gives it the memory, the tools, the rules, and the oversight** — everything that turns raw intelligence into a dependable team member.
***
## What is Agentium? (the technical version)
**Agentium** is a TypeScript-native agent orchestration framework for Node.js. It provides a complete toolkit for building AI-powered applications—from simple chatbots to complex multi-agent systems—with **zero meta-framework dependency**. Write pure TypeScript, plug in your preferred LLM provider, and ship production-ready agent applications.
Agentium is designed for developers who want:
* **Full control** over their agent architecture
* **Native TypeScript** without Python runtime or transpilation layers
* **Flexibility** to swap models, storage, and transport layers without rewriting code
* **Production readiness** with built-in session management, memory, RAG, and background job queues
***
## Key Features
Use OpenAI, Anthropic, Google Gemini, or Ollama with a unified interface. Switch providers with a single line change.
Coordinate, route, broadcast, and collaborate across multiple agents. Build sophisticated agent hierarchies.
Define agent steps, conditions, and parallel execution. Orchestrate complex multi-step pipelines.
Zod-validated tool definitions with type-safe execution. Full support for OpenAI-compatible function calling.
Vector stores, embeddings, and retrieval. Build context-aware agents with your own documents.
Handle images, audio, and files. Pass rich content to vision and audio-capable models.
Express REST API and Socket.IO WebSocket gateway. Expose agents as HTTP or real-time endpoints.
BullMQ queue and worker support. Process long-running tasks asynchronously.
In-memory, SQLite, PostgreSQL, and MongoDB. Choose the right persistence for your scale.
Session history, LLM-powered long-term summaries, and cross-session user memory. Three complementary layers.
Speech-to-speech conversations via OpenAI Realtime and Google Gemini Live. Same tools, same memory, real-time audio.
Vision-based autonomous browser automation. An agent sees screenshots, decides actions, and operates web pages via Playwright.
Run tools in isolated subprocesses with timeout and memory limits. Fully optional — off by default.
Pause the agent loop for human approval before executing sensitive tools. CLI, event-driven, or Socket.IO.
***
## Why Agentium?
LangGraph.js is a powerful low-level orchestration framework, but it requires you to model everything as a directed state graph — defining nodes, edges, reducers, and conditional routing. It's explicitly described as "very low-level, focused entirely on agent orchestration." Agentium takes a higher-level, declarative approach: define an Agent with tools, a Team with members, or a Workflow with steps — no graph theory required.
Both frameworks support human-in-the-loop, streaming, and state persistence. Where they diverge:
* **Voice agents**: LangGraph has no built-in voice support — you'd need to integrate LiveKit or another real-time layer yourself. Agentium ships `VoiceAgent` with OpenAI Realtime and Google Live providers out of the box.
* **Browser automation**: Not part of LangGraph. Agentium includes `BrowserAgent` with Playwright, stealth mode, credential vaulting, and video recording.
* **Multi-agent teams**: LangGraph supports multi-agent via handoffs and supervisor patterns, but you wire the graph manually. Agentium provides `Team` with four built-in modes (coordinate, route, broadcast, collaborate) — one config object.
* **Transport**: LangGraph relies on LangGraph Platform (paid) for deployment. Agentium ships free Express, Socket.IO, and A2A transport out of the box.
The Vercel AI SDK (v6) is a solid choice for single-agent tool-calling loops, especially if you're already on Vercel. It has good model provider support, tool validation via Zod, and a `ToolLoopAgent` class. However, it's designed primarily for individual agents inside Vercel's ecosystem.
Where Agentium goes further:
* **Multi-agent teams**: The AI SDK has no built-in team coordination. Agentium provides `Team` with coordinator, router, broadcast, and collaborate modes.
* **Workflows**: The AI SDK offers workflow "patterns" (docs examples), but no first-class `Workflow` class with typed state, parallel steps, retry policies, and conditions. Agentium does.
* **Voice agents**: The AI SDK has `speech` and `transcription` utilities, but no real-time bidirectional voice agent. Agentium has `VoiceAgent` with OpenAI Realtime and Google Live.
* **Browser agents**: Not part of the AI SDK. Agentium includes `BrowserAgent`.
* **Background jobs**: The AI SDK relies on Vercel's Fluid Compute (`waitUntil`). Agentium provides a standalone `@agentium/queue` package with BullMQ — runs anywhere, not just Vercel.
* **Framework lock-in**: The AI SDK is optimized for Vercel + React. Agentium is framework-agnostic — Express, Fastify, Socket.IO, or headless.
LangChain.js is a large ecosystem with integrations for nearly every vector store, memory backend, and LLM provider. It's great if you need breadth. However, the chain-based abstraction layer sits between you and the LLM, and the framework is actively steering users toward LangGraph for anything beyond simple chains (`AgentExecutor` is deprecated, sunset December 2026).
Agentium takes a different philosophy:
* **Direct control**: You work with `Agent`, `Team`, and `Workflow` directly — no chain composition or `AgentExecutor` to reason about.
* **Batteries-included**: Session management, user memory, hybrid RAG (BM25 + vector), voice agents, browser automation, sandbox execution, and human-in-the-loop are all first-class — not spread across `langchain`, `@langchain/community`, and `langgraph`.
* **Simpler mental model**: One framework, one set of docs. LangChain.js users currently need to decide between LangChain, LangGraph, LangSmith, and LangServe — each with its own API surface.
CrewAI is Python-only (98% Python on GitHub). Autogen supports Python and .NET, with more languages "coming." Neither has native TypeScript support. If your stack is Node.js, you'd need to run a separate Python service, manage two runtimes, and deal with inter-process communication.
Agentium keeps everything in TypeScript — same language, same process, same deployment. It also provides capabilities that these frameworks don't:
* **Real-time voice agents** with OpenAI Realtime and Google Live
* **Autonomous browser agents** with Playwright and stealth mode
* **Transport gateways** (Express REST, Socket.IO, Voice Gateway, Browser Gateway)
* **Background job queues** with BullMQ
* **Sandbox execution** for isolated tool running
***
## Get Started
Ready to build your first agent? Head to the [Quickstart](/quickstart) to install Agentium and run a simple example in under five minutes.
Install, configure, and run your first Agentium agent in minutes.