The JavaScript agent toolkit that doesn't lock you in. 5.17 KB gzipped. Zero dependencies. Six contracts pinned to ADRs. Forever stable at the minor level.

The JavaScript agent toolkit just hit 1.0

5.17 KB gzipped. Zero dependencies. Six contracts pinned to ADRs.

Today, @agentskit/core graduates to v1.0.0 — the stable substrate for every agent you'll ship in JavaScript this decade.

npm install @agentskit/core@1

The numbers behind v1


Core bundle	5.17 KB gzipped — 48% under the 10 KB Manifesto budget
Runtime deps	Zero
Packages	14, independently installable
Tests	538 passing across the ecosystem
ADR-pinned contracts	6 (Adapter, Tool, Memory, Retriever, Skill, Runtime)
PRs through the gauntlet	18 in Phase 0 + 9 in Phase 1, zero contract breakage

Every number above is enforced in CI. The budget isn't a goal — it's a gate.

The problem with building agents in JavaScript today

Pick your poison:

Heavyweight SDKs that drag 200 KB of transitive dependencies into your bundle, couple you to one provider, and ship breaking changes every minor version.
Glue primitives yourself — spend six months writing adapter layers, retry logic, tool contracts, memory abstractions, and an evaluation harness before you ship one line of product code.
Pick a framework — inherit its opinions, its abstractions, its lifetimes, and the day it stops being maintained you're stuck.

None of these are fine. The agent era deserves a substrate that works like React does for UI: small, stable, composable, and out of your way.

What AgentsKit.js actually is

AgentsKit.js is a family of 14 small packages built on one 5 KB core. Every package is plug-and-play. Every contract is open. Every combination composes.

@agentskit/core            ← pure foundation, zero deps, v1.0.0
  ├── adapters             ← OpenAI, Anthropic, Gemini, Ollama, LangChain, Vercel AI, any ReadableStream
  ├── react                ← useChat + headless components for the browser
  ├── ink                  ← same hooks, same components, for the terminal
  ├── cli                  ← agentskit init / chat / dev / doctor / tunnel
  ├── runtime              ← standalone agent loop (ReAct, reflection, multi-agent)
  ├── tools                ← browser, fs, web search, code exec, email, calendar
  ├── skills               ← researcher, critic, writer, planner, coder
  ├── memory               ← in-memory, file, SQLite, Redis, vector
  ├── rag                  ← plug-and-play retrieval in 3 lines
  ├── sandbox              ← E2B + WebContainer code execution
  ├── observability        ← LangSmith, OpenTelemetry, cost guards
  ├── eval                 ← agent benchmarking for CI
  └── templates            ← production-ready starters

Install the two you need. Skip the twelve you don't. The API surface you use is the only surface you pay for.

Why v1 is a promise, not a version bump

Shipping a "1.0" means almost nothing. Keeping it stable is the work.

With v1, @agentskit/core commits to:

API frozen at the minor level. Breaking changes require a major bump and a deprecation cycle.
Contracts pinned to ADRs. Any change to Adapter, Tool, Memory, Retriever, Skill, or Runtime contracts requires a new ADR + coordinated major bump across affected packages.
Deprecations live for ≥ 1 minor release before removal.
Every user-facing change ships with a changeset describing the impact.

The substrate stops moving. Your code stops breaking.

What else shipped this cycle (Phase 1)

Nine developer-experience + runtime features across nine PRs:

`agentskit init` — interactive starter in 60 seconds

Five questions, four templates (react, ink, runtime, multi-agent), demo provider runs zero-config.

`agentskit doctor` — one-shot diagnostics

Node version, package manager, deps, config, provider keys, reachability. Non-zero exit on fail — CI-ready.

`agentskit dev` — hot-reload for agents

chokidar watcher, debounced restarts, r to restart, q to quit. Stop babysitting your agent process.

Auto-retry with exponential backoff

Built into every adapter. Transient failures (408, 429, 5xx) retry with jitter. Terminal failures (4xx auth) don't. Respects Retry-After.

Dry-run primitives

mockAdapter, recordingAdapter, replayAdapter, inMemorySink. Test agents without burning tokens. Foundation for deterministic replay.

`costGuard`

Enforce a dollar budget per run. Observer + AbortController. Tracks usage, computes cost, aborts cleanly. Custom pricing tables supported.

`edit` + `regenerate` on `ChatController`

Optimistic-UI contract preserved. React and Ink hooks mirror the new surface automatically.

Breaking changes from 0.4.x

Two import swaps. Both driven by Manifesto principle 1 — core works in any environment, including browsers:

- import { createFileMemory } from '@agentskit/core'
+ import { fileChatMemory } from '@agentskit/memory'

- import { loadConfig } from '@agentskit/core'
+ import { loadConfig } from '@agentskit/cli'

That's it. Both helpers were Node-only and crashed browser consumers. Moving them to the packages that already carry Node dependencies restored universal core compatibility. Full guide: Migrating from 0.4 to 1.0.

The ten principles that got us here

From the Manifesto, with v1 scorecards:

✅ Core under 10 KB gzipped, zero deps — 5.17 KB, zero deps
✅ Every package plug-and-play — 14 packages, independently installable
✅ Interop radical — any combination composes
✅ Zero lock-in — all contracts open, storage local-first
✅ Agent-first — runtime, skills, delegation are first-class
✅ Docs are product — 74 Fumadocs routes, 7 ADRs, 13 recipes, 3 migration guides
✅ TypeScript rigor — no any, named exports only, strict mode
✅ Small, deep, testable modules — 538 tests, coverage gates in CI
✅ Predictable beats clever — one entry point per primitive
✅ Open by default — roadmap, RFCs, ADRs all public

What Phase 2 looks like

Additive. The substrate holds. Highlights from the Master PRD:

Deterministic replay + prompt diff + time-travel debug
Hierarchical memory (MemGPT-style) + hybrid search + reranking
Durable execution, multi-agent topologies, HITL primitives
PII redaction, prompt injection detector, audit log

None of it requires a breaking change to core. That's the point of v1.

Built by one. Ready for many.

Everything you just read — 14 packages, 538 tests, 6 ADR contracts, two full release phases — was shipped by one maintainer (Emerson Braun).

That's a signal about the architecture, not a flex. The substrate is small enough, the contracts are clear enough, and the tests are rigorous enough that one person can hold the whole thing in their head. That's the point. It means you can, too.

And it means every PR from here forward compounds.

The gaps where your name could go next:

New adapters — Cohere, Mistral, Together, Groq, Bedrock, Azure OpenAI
New tools — anything in @agentskit/tools that doesn't exist yet
New skills — your best system prompt, packaged and shareable
New templates — starter kits for real use cases (customer support, research assistant, code reviewer)
Translations — docs in your language (i18n RFC lands Phase 2)
Recipes — one page, one problem, one working solution

Every contract is pinned to an ADR. Every package ships with tests and a size budget. The bar is high, the scope is clear, and the code is small. Open an issue, send a PR, or just star the repo — the roadmap is public and every RFC is open.

Public roadmap → · Contributing guide →

The board is maintainer-curated, but the inbox is open to everyone: file an issue or a discussion and it gets triaged onto the roadmap.

Start building

npm install @agentskit/core@1 @agentskit/react @agentskit/adapters
# or
pnpm add @agentskit/core@1 @agentskit/react @agentskit/adapters

A working chat in under 10 lines: Quick start →

The mental model behind every package: Concepts →

Why this exists: Origin →

Day one is over. Day two starts with a real v1.

✎ Edit this page on GitHub·Found a problem? Open an issue →·How to contribute →

@agentskit/core hits 1.0