Introducing kernl

Today we're excited to introduce kernl, a TypeScript framework for building agents that remember, reason, and act.

The pitch is simple: agents that work in production, built on infrastructure you can actually understand.

Why this exists

I was astounded to learn that 85% of production agents are still custom code.. ¹

So I asked myself, "Why are people hand-rolling the same code over and over again, alone?"

We clearly need a unified framework for building them, but why doesn't this exist?

These are the three main reasons teams cited for throwing away frameworks after trying them:

Dependency hell. "LangChain pulls in 47 packages. Our security team said no."
Abstraction mismatch. "We spent more time fighting the framework than solving our problem."
Debugging nightmares. "When it breaks, we need to read THEIR code, not ours."

This is the state of things today: roll your own and drown in accidental complexity, or use a framework and fight it until you fork it.

We think there's a third option.

How we think about this

Software 3.0 needs better infrastructure—that's what we're building.

Aggressive minimalism is at the heart of the design ethos behind this company, and the belief in quality is central to its DNA.

Every line of code, and every addition to the framework is intentional. Ruthless simplification is a never ending war that we will continue to wage.

In practice, this means 3 external dependencies—not 47. Functions you can read in one sitting if you want to browse the source.

And lastly it means building in the open. The Linux spirit—code that belongs to everyone, shaped by the people who use it. We want to cultivate a community, not a customer base.

Why kernl

This is just the beginning, but here are a few reasons why choose kernl today:

Toolkit marketplace. Open by design, customizable to your needs. Browse, copy, own. The code lives in your repo, not ours.

kernl add toolkit github

There's no magic under the hood, no remote server you have to rely on — it works just like shadcn and copies the toolkit into your project so you can edit the code to your needs.

Thread persistence. Simple storage configuration, no managing message threads manually. Conversations just work.

import { Kernl } from "kernl";
import { postgres } from "@kernl-sdk/pg";
 
const kernl = new Kernl({
  storage: {
    // this is all you need to configure persistence
    db: postgres({ connstr: process.env.DATABASE_URL }),
  },
});
 
await jarvis.stream("My name is Tony.", { 
  threadId: "thread_123" 
});
 
// resumes the same thread
await jarvis.stream("What's my name?", { 
  threadId: "thread_123" 
});

Memory. Namespace-scoped memories that outlive individual threads. Agents that actually remember.

const jarvis = new Agent({
  id: "jarvis",
  name: "J.A.R.V.I.S.",
  model: anthropic("claude-sonnet-4-5"),
  instructions: "Help Tony Stark save the world from destruction.",
  // this enables Jarvis to see and search its own memories, across threads
  memory: { enabled: true }, 
});
 
await jarvis.memories.create({
  namespace: "org-a", // optional namespacing for multi-tenant use cases
  collection: "preferences",
  content: { text: "Tony prefers his coffee extra strong." },
});

A couple of our principles

These are a few of the ideals that we will strive to live up to, and will continue to cultivate as part of this ecosystem's DNA:

Aggressive minimalism. Every abstraction earns its place. If it doesn't need to exist, it doesn't.
An open world, a strong community. We're building for interoperability, not lock-in. We believe in the power of collective intelligence and decentralization.
Composition over inheritance. Take what you need, leave what you don't.
Opinionated, not constricting. Sensible defaults, escape hatches where you need them.
Your environment, your control. You decide where your agents run. The execution environment is yours.

Getting started

pnpm create kernl@latest

import { Kernl, Agent } from "kernl";
import { anthropic } from "@kernl-sdk/ai/anthropic";
 
import { math } from "@/toolkits/math";
 
const kernl = new Kernl();
 
const agent = new Agent({
  id: "assistant",
  model: anthropic("claude-sonnet-4-5"),
  instructions: "You are a helpful assistant.",
  toolkits: [math]
});
 
kernl.register(agent);
 
await agent.run("Hello, world.");

Read the docs. Browse the marketplace.

This is just the beginning. We're excited to build with you!

1. Pan et al., "Measuring Agents in Production," 2025.