The agent toolkit JavaScript actually deserves.
A 10 KB core. Twenty-four focused packages. Zero lock-in. Six formal contracts that make every adapter, tool, skill, memory, retriever, and runtime substitutable.
Documentation · Discord · Roadmap · Manifesto · Origin · Architecture
You started building an AI agent last week. You're three libraries deep, two of them fight each other, and nothing you wrote is reusable. This is for you.
⭐ If this saves you from gluing five libraries together, star the repo. AgentsKit is solo-built — a star is the cheapest signal that it's worth continuing, and it's what puts it in front of the next person.
We don't need another framework. We need a kit.
Building a real AI agent in JavaScript today means cobbling together five libraries that don't fit. Vercel AI SDK is a beautiful chat SDK with no runtime. LangChain.js drags in 200MB and leaks abstractions at every layer. MCP solves tool interop and nothing else. assistant-ui has 53 components and no opinion about how to compose them.
AgentsKit is the missing kit: small, contracted, composable. Start with one package, grow into a full stack, and stay in plain JavaScript the entire time.
Origin story for the long version. Manifesto for the principles.
Four properties, one job each. Start where your goal is:
| I want to… | Go to | What it is |
|---|---|---|
| Build an agent from scratch in JavaScript | AgentsKit — you're here | The toolkit: core, adapters, runtime, tools, memory, RAG, and UI for every framework |
| Drop in a ready-made agent | Registry → | The shadcn for agents — copy-paste, installable agents |
| Run agents in production | AKOS → | AgentsKit OS — the operating system for AI agents in production (managed cloud / self-hosted) |
| Learn enterprise best practices | Playbook → | Methodology and patterns for building production agents |
Grab what you want from AgentsKit, follow best practices in the Playbook, drop in ready-made agents from the Registry, and run them in production on AKOS.
npm install @agentskit/react @agentskit/adaptersimport { useChat, ChatContainer, Message, InputBar } from '@agentskit/react'
import { anthropic } from '@agentskit/adapters'
import '@agentskit/react/theme'
export default function Chat() {
const chat = useChat({ adapter: anthropic({ apiKey: KEY, model: 'claude-sonnet-4-6' }) })
return (
<ChatContainer>
{chat.messages.map(m => <Message key={m.id} message={m} />)}
<InputBar chat={chat} />
</ChatContainer>
)
}Streaming, tool calls, default styling, abortable. No setup. No boilerplate.
Before — the typical "JS agent" stack:
// Pick your favorite: LangChain, raw fetch, Vercel AI SDK + custom runtime,
// MCP client + custom UI, manual ReAct loop, hand-rolled streaming...
// Then wire memory. Then wire tools. Then wire delegation. Then debug.After — AgentsKit:
import { createRuntime } from '@agentskit/runtime'
import { openai } from '@agentskit/adapters'
import { webSearch, filesystem } from '@agentskit/tools'
const runtime = createRuntime({
adapter: openai({ apiKey: KEY, model: 'gpt-4o' }),
tools: [webSearch(), ...filesystem({ basePath: './workspace' })],
})
const result = await runtime.run('Research the top 3 AI frameworks and save a summary')That's an autonomous agent. With a tool registry. With memory. With observability hooks. Two imports, six lines.
Swap providers in one line — every other line stays the same:
import { anthropic, openai, gemini, ollama, deepseek, grok } from '@agentskit/adapters'
useChat({ adapter: anthropic({ apiKey, model: 'claude-sonnet-4-6' }) })
useChat({ adapter: openai({ apiKey, model: 'gpt-4o' }) })
useChat({ adapter: ollama({ model: 'llama3.1' }) }) // local, no key| AgentsKit | Vercel AI SDK | LangChain.js | assistant-ui | |
|---|---|---|---|---|
| Core size | 10KB gzip, zero deps | ~30KB | hundreds of MB transitively | n/a (UI only) |
| Agent runtime | First-class (ReAct, tools, skills, delegation, memory, RAG) | None | Yes, but heavy | None |
| Provider swap | One line | Route-handler-shaped | Per-class wiring | BYO backend |
| UI surfaces | React + Ink + headless | React | None | React |
| Formal contracts | Six versioned ADRs | Implicit | Implicit | Implicit |
| Edge-ready | Yes (10KB core, no Node-only deps) | Mostly | No | n/a |
We are honest about this:
- You only need a single OpenAI streaming call. Use the
openaiSDK directly — AgentsKit is overkill. - You're shipping a chat SDK to consumers, not an agent. Vercel AI SDK is purpose-built for that and excellent.
- You need Python. AgentsKit is JavaScript-first by design. Use a Python framework.
- You require enterprise-grade observability today. AgentsKit's observability layer is good but young; LangSmith/Arize/Helicone are more mature integrations right now.
- You need every package frozen today.
@agentskit/coreis v1.0.0, but the rest of the ecosystem is still graduating package-by-package.
Full, honest head-to-head with LangChain.js, Vercel AI SDK, Mastra, LlamaIndex.js, and assistant-ui → AgentsKit vs alternatives.
Pick what you need. Every package works alone. Combinations work without glue code.
| Package | What it does | Stability |
|---|---|---|
@agentskit/core |
Types, contracts, primitives | stable |
@agentskit/adapters |
Provider adapters (OpenAI, Anthropic, Gemini, Ollama, DeepSeek, Grok, …) | beta |
@agentskit/runtime |
Autonomous agent runtime (ReAct loop, delegation) | beta |
@agentskit/tools |
Web search, filesystem, shell, integrations, MCP bridge | beta |
@agentskit/memory |
Chat + vector + graph + encrypted memory | beta |
@agentskit/rag |
Plug-and-play retrieval and reranking | alpha |
@agentskit/skills |
Pre-built behavioral prompts and personas | beta |
@agentskit/observability |
Console, LangSmith, OpenTelemetry, audit log | beta |
@agentskit/eval |
Agent evaluation, replay, snapshots | alpha |
@agentskit/sandbox |
Secure code execution | alpha |
@agentskit/react |
React hooks + headless UI | beta |
@agentskit/ink |
Terminal UI (Ink) components | beta |
@agentskit/vue |
Vue binding for the shared chat contract | alpha |
@agentskit/svelte |
Svelte binding for the shared chat contract | alpha |
@agentskit/solid |
Solid binding for the shared chat contract | alpha |
@agentskit/react-native |
React Native / Expo binding | alpha |
@agentskit/angular |
Angular binding with Signals + RxJS | alpha |
@agentskit/cli |
CLI: chat, init, run, ai, dev, doctor | beta |
@agentskit/templates |
Authoring toolkit for scaffolding skills, tools, adapters | alpha |
@agentskit/mcp |
Expose AgentsKit tools as an MCP server (Claude Desktop, Cursor, Windsurf) | beta |
@agentskit/integrations |
Plug-and-play service integrations (one descriptor → tools, connectors, triggers, auth) | beta |
@agentskit/validation |
Runtime JSON-Schema validation of tool-call arguments (Ajv) | beta |
@agentskit/eval-braintrust |
Braintrust scoring pipeline + CI regression alerts | beta |
@agentskit/observability-langfuse |
Langfuse tracing adapter (plan, tool, model, HITL spans) | beta |
One kit, many shapes. Reach for only what the goal needs:
| Goal | Reach for |
|---|---|
| Streaming chat UI in React | react + adapters |
| The same chat in Vue / Svelte / Solid / Angular / React Native | the matching binding + adapters |
| Terminal or CLI agent | ink + cli |
| Headless autonomous agent (no UI) | runtime + tools + skills |
| Swap LLM providers with one line | adapters (OpenAI, Anthropic, Gemini, Ollama, DeepSeek, Grok, …) |
| Long-term, vector, or encrypted memory | memory |
| RAG over your own docs | rag + memory |
| Multi-agent delegation | runtime + skills |
| Use your tools from Claude Desktop / Cursor | mcp |
| Connect Slack, Teams, email, … | integrations |
| Run untrusted or model-generated code | sandbox |
| Trace, evaluate, and observe | observability + eval |
The whole catalog is one npx @agentskit/cli init away.
import { planner, researcher, coder } from '@agentskit/skills'
const result = await runtime.run('Build a landing page about quantum computing', {
skill: planner,
delegates: {
researcher: { skill: researcher, tools: [webSearch()], maxSteps: 3 },
coder: { skill: coder, tools: [...filesystem({ basePath: './src' })], maxSteps: 8 },
},
})The planner decomposes the task. The researcher and coder execute their parts. Delegation happens through a tool the model already knows how to call — no special syntax to learn.
npm install -g @agentskit/cli
agentskit chat --provider ollama --model llama3.1
agentskit chat --provider openai --tools web_search,shell --skill researcherThe same useChat mental model. Real keyboard input. Real streaming. Real tools.
The full public API fits in under 2,000 tokens. Paste the agent-friendly reference into your LLM context and start generating real AgentsKit code immediately. We treat agents as first-class consumers of our docs.
graph TD
core["@agentskit/core\n(zero deps · 5 KB)"]
adapters["@agentskit/adapters\nOpenAI · Anthropic · Gemini\nOllama · DeepSeek · Grok"]
react["@agentskit/react\nReact hooks + headless UI"]
ink["@agentskit/ink\nTerminal UI (Ink)"]
runtime["@agentskit/runtime\nReAct loop · delegation"]
tools["@agentskit/tools\nweb search · filesystem · shell"]
skills["@agentskit/skills\nresearcher · coder · planner"]
memory["@agentskit/memory\nSQLite · Redis · file · vector"]
rag["@agentskit/rag\nplug-and-play RAG"]
observability["@agentskit/observability\nLangSmith · OpenTelemetry"]
sandbox["@agentskit/sandbox\nE2B · WebContainer"]
eval["@agentskit/eval\nbenchmarking · metrics"]
templates["@agentskit/templates\nskill/tool authoring"]
cli["@agentskit/cli\nchat · init · run"]
core --> adapters
core --> react
core --> ink
core --> runtime
core --> tools
core --> skills
core --> memory
core --> rag
core --> observability
core --> sandbox
core --> eval
core --> templates
cli --> core
cli --> adapters
cli --> ink
cli --> runtime
cli --> skills
cli --> tools
cli --> memory
classDef foundation fill:#1e293b,stroke:#6366f1,color:#f8fafc,font-weight:bold
classDef ui fill:#0f172a,stroke:#22d3ee,color:#f8fafc
classDef agent fill:#0f172a,stroke:#a78bfa,color:#f8fafc
classDef data fill:#0f172a,stroke:#34d399,color:#f8fafc
classDef ops fill:#0f172a,stroke:#fb923c,color:#f8fafc
classDef entry fill:#0f172a,stroke:#f472b6,color:#f8fafc
class core foundation
class react,ink ui
class adapters,runtime,tools,skills agent
class memory,rag,templates data
class observability,sandbox,eval ops
class cli entry
Legend: purple = provider/execution layer · cyan = UI layer · green = data layer · orange = ops layer · pink = CLI entry point
Six ADRs define the substrate:
| ADR | Contract |
|---|---|
| 0001 | Adapter — LLM provider seam |
| 0002 | Tool — function the model calls |
| 0003 | Memory — chat history + vector store + embed |
| 0004 | Retriever — context fetching |
| 0005 | Skill — declarative persona |
| 0006 | Runtime — the loop that composes them all |
Read these once and you can predict how every package behaves.
@agentskit/core is at v1.0.0 — API frozen at the minor level, deprecations carry a cycle, contracts pinned to ADRs. The rest of the ecosystem ships on independent beta/alpha tracks with explicit stability tiers.
Concretely, as of the Phase 1 release:
- 538 tests across the ecosystem
- 5.17 KB gzipped core — 48% under the 10 KB manifesto budget (enforced in CI)
- Six formal contracts pinned to ADRs 0001–0006
- 74 documentation routes including 13 copy-paste recipes and 3 migration guides
See the Phase 1 release notes for what shipped, and the roadmap burn-down for what's next.
AgentsKit is built in the open and ships because contributors show up. Every package, every doc, every example is fair game.
- How to contribute → — start here
- Public roadmap board — what's planned, in flight, and shipped
- Good-first-issues — curated, tractable tickets
- Help-wanted — larger scoped work
- Discussions — ask, propose, share
- RFC template — open before touching a contract
CONTRIBUTING.md— dev setup + PR checklist
Thanks to everyone who's shipped a line of code, docs, or feedback.
MIT — see LICENSE.