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.

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.

Quick start — chat in 10 lines

npm install @agentskit/react @agentskit/adapters

import { 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 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

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.

The ecosystem

Pick what you need. Every package works alone. Combinations work without glue code.

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:

Read these once and you can predict how every package behaves.

Status

@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 Master PRD for what's next.

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

Contributors

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

License

MIT — see LICENSE.