The agent toolkit JavaScript actually deserves.
A 10 KB core budget. Twenty-five focused packages. Zero lock-in. Six formal contracts that make every adapter, tool, skill, memory, retriever, and runtime substitutable.
Tags: agentskit · ai-agents · typescript · javascript · llm · agent-runtime · tools · rag
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.
The current evidence ledger, generated from repository sources by scripts/compute-stats.mjs, verifies 25 published packages, 7 framework bindings, 25 native adapters, 50 integrations, 140 catalog providers, 5,000+ catalog models, 21 ready-made skills, 17 memory backends, and 69 recipes.
- The core has zero runtime dependencies and a CI-enforced 10 KB gzipped budget.
- Every public package has an explicit stability tier, test floor, README, human guide, and agent handoff.
- Numeric claims fail CI when their repository derivation, committed snapshot, or public evidence drifts.
Inspect the machine-readable claims ledger, ecosystem contract, and Doc Bridge index instead of trusting a screenshot or an unversioned marketing count.
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.
AgentsKit is not only a package. It is the open-source foundation of a full agent ecosystem: build from composable parts, start faster with ready agents, follow production patterns, and run the result with enterprise controls.
| Layer | Go to | What it unlocks |
|---|---|---|
| AgentsKit | This repo | The agent building blocks: adapters, runtime, tools, memory, RAG, UI, evals, observability, and MCP |
| Registry | registry.agentskit.io → | Ready-to-use agents, tools, and templates you can install instead of starting from blank |
| Playbook | playbook.agentskit.io → | Field-tested patterns for designing, evaluating, securing, and operating agents |
| AKOS | akos.agentskit.io → | The enterprise operating system for deploying, governing, observing, and scaling agents |
The path is simple: compose with AgentsKit, learn the patterns in the Playbook, reuse agents from the Registry, and graduate to AKOS when you need enterprise operations.
flowchart LR
Playbook["Playbook<br/>best practices"]
Registry["Registry<br/>ready agents"]
AK["AgentsKit<br/>composable JS packages"]
AKOS["AKOS<br/>enterprise agent OS"]
Playbook --> AK
Registry --> AK
AK --> Registry
AK --> AKOS
Playbook --> AKOS
Humans get the docs site. Agents get llms.txt and doc-bridge.config.json: 24/24 package handoffs, 24/24 human-doc bridges.
npm install @agentskit/core @agentskit/runtime tsxCreate agent.ts:
import type { AdapterFactory } from '@agentskit/core'
import { createRuntime } from '@agentskit/runtime'
const localAdapter: AdapterFactory = {
createSource(request) {
const task = request.messages.at(-1)?.content ?? 'your task'
return {
async *stream() {
yield {
type: 'text' as const,
content: `Agent ready. I received: ${task}`,
}
yield { type: 'done' as const }
},
abort() {},
}
},
}
async function main() {
const runtime = createRuntime({ adapter: localAdapter })
const result = await runtime.run('Plan my first production agent')
console.log(result.content)
}
void main()npx tsx agent.tsIt prints Agent ready. I received: Plan my first production agent. No account, API key, or network request is required. The executable fixture is byte-synchronized with this README and runs in CI; connect any supported provider later through the same adapter contract.
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/tools/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.
AgentsKit targets Node.js 20+ and modern JavaScript runtimes. Packages ship strict TypeScript declarations and dual ESM/CJS output unless their platform binding documents a narrower target. Browser, edge, React Native, Angular, Vue, Svelte, Solid, React, and terminal compatibility is package-specific and declared in each package README and guide.
The current verified release surface is:
- Stable:
@agentskit/core, with six formal contracts pinned to ADRs 0001–0006. - Beta/alpha: every other package graduates independently under the published stability policy.
- Evidence: current package, adapter, integration, provider, skill, memory, and recipe counts come from the generated claims ledger, not this prose.
See the stability policy, core v1 release notes, and public roadmap before depending on a pre-1.0 package contract.
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- README Standard v1 — executable quality profiles for repositories, apps, and packages
Thanks to everyone who's shipped a line of code, docs, or feedback.
MIT — see LICENSE.