---

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.

Verified proof

The current evidence ledger, generated from repository sources by scripts/compute-stats.mjs, publishes the canonical package, framework, adapter, integration, provider, model, skill, memory, and recipe counts used by every AgentsKit surface.

• 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.

Why this exists

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.

---

The AgentsKit ecosystem

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.

---

Quick start — your first agent, no key required

npm install @agentskit/core @agentskit/runtime tsx

Create 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.ts

It 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 and after

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

---

How AgentsKit compares

	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

When you should NOT use AgentsKit

We are honest about this:

• You only need a single OpenAI streaming call. Use the openai SDK 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/core is 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.

---

The packages

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

What can you build?

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.

---

Multi-agent delegation

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.

---

Terminal chat (Ink)

npm install -g @agentskit/cli
agentskit chat --provider ollama --model llama3.1
agentskit chat --provider openai --tools web_search,shell --skill researcher

The same useChat mental model. Real keyboard input. Real streaming. Real tools.

---

For AI agents reading this

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.

---

Package dependency graph

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

---

Architecture and contracts

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.

---

Maturity and compatibility

@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.

---

Contributing

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

Contributors

Thanks to everyone who's shipped a line of code, docs, or feedback.

---

License

MIT — see LICENSE.