Kimten: a tiny agent loop for Node.js (without the framework weight)

Sayan "Riju" Chakrabarti — Tue, 17 Feb 2026 08:47:16 +0000

While building small AI utilities, I kept running into the same problem:

agent frameworks felt heavy
ad-hoc tool calling became messy
workflows quickly turned into glue code

I wanted something in between.

So I built Kimten — a minimal micro-agent loop on top of the Vercel AI SDK.

What Kimten is

Kimten is a thin wrapper over the AI SDK Agent interface that gives you:

a bounded agent loop (no infinite reasoning spirals)
tool/function calling
short-term conversation memory
optional structured output via Zod
predictable, minimal behavior

No planners. No orchestration. No runtime magic.

It’s meant to feel like a smart helper, not a framework.

Why I built it

Many LLM apps don’t need multi-agent graphs or orchestration layers.

They just need:

“let the model call a function”
small automation workflows
structured extraction
quick utilities & scripts

Kimten is designed for tiny, disposable agents that solve one job well.

Where it fits well

Kimten works nicely for:

CLI helpers
scripting & automations
local utilities
quick AI tools
structured extraction tasks
“summarize → refine → extract” flows

Each instance keeps short-term memory, so follow-ups like:

summarize this → make it shorter → extract bullets

just work.

What it intentionally does NOT do

To keep behavior predictable:

no planners or state machines
no persistence or long-term memory
no multi-agent orchestration
no plugin ecosystem
no streaming API surface

If you need 50+ steps, you probably need a planner — not Kimten.

Usage Example

npm i @tabbybyte/kimten ai zod @ai-sdk/openai

import { openai } from '@ai-sdk/openai';
import { z } from 'zod';
import Kimten from '@tabbybyte/kimten';

// schema used only when we want structured output
const SummaryBox = z.object({
  summary: z.string(),
  keywords: z.array(z.string()),
});

const cat = Kimten({
  brain: openai('gpt-4o-mini'),
  personality: 'You summarize content clearly.',
});

// 1️⃣ free-form text output
const text = await cat.play(
  'Explain what Node.js is in one sentence.'
);

console.log(text);
// → plain string


// 2️⃣ structured output using box mode
const jsonCat = Kimten({
  brain: openai('gpt-4o-mini'),
  personality: 'Summarize and extract keywords.',
  box: SummaryBox,
});

const structured = await jsonCat.play(`
Node.js is an open-source runtime built on Chrome’s V8 engine.
It allows JavaScript to run on the server and is widely used
for scalable network applications.
`);

console.log(structured);
// → { summary: "...", keywords: [...] }

Design philosophy

Kimten focuses on:

Predictability over magic
Small surface area over extensibility
Disposable agents over runtime mutation

Instead of rewiring behavior, you steer the agent via:

prompt input
ephemeral context
tool definitions

When a simple loop stops being enough

In my experience, complexity creeps in when you need:

long-running workflows
task planning & decomposition
shared memory across agents
persistence & retrieval
human-in-the-loop orchestration

Until then, a tiny loop often gets the job done.

Try it

GitHub: https://github.com/tabbybyte-technologies/kimten
npm: https://www.npmjs.com/package/@tabbybyte/kimten

I’d love feedback from folks building real-world LLM tooling — especially where you think the “tiny loop” approach breaks down.

DEV Community: Sayan "Riju" Chakrabarti