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

Posted on by — No Comments ↓

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.

Leave a Reply