v0.1.0-alpha · Now on npm

The runtime your
AI agents deserve

Open-source infrastructure for autonomous AI agents. Process lifecycle, memory, tools, messaging, and scheduling — so you can focus on building intelligence, not plumbing.

Get Started Star on GitHub
$ npm install @llmhut/agentvm click to copy
agentvm console
$ npx @llmhut/agentvm init my-project ✔ Project created! $ cd my-project && npx agentvm start ✔ Kernel "my-project" loaded Agents registered: 1 • greeter — A friendly agent agentvm> spawn greeter ✔ Spawned process greeter-1-m7x2k agentvm> exec greeter-1-m7x2k Hello World ✔ Completed in 2ms Output: "Hello, World! (greeting #1)" agentvm> exec greeter-1-m7x2k Aakash ✔ Completed in 1ms Output: "Hello, Aakash! (greeting #2)"

Architecture

Five modules.
One runtime.

AgentVM sits beneath your agent framework — handling the OS-level concerns so you can focus on reasoning, planning, and workflow design.

Your Agent Framework
LangChain · CrewAI · AutoGen · your own code
AgentVM API
kernel.spawn() · kernel.execute() · kernel.terminate()
Process
Manager
Memory
Bus
Tool
Router
Message
Broker
Task
Scheduler

Features

Everything agents need.
Nothing they don't.

Each module works standalone or together. Use just the memory bus. Use just the scheduler. Mix and match.

P

Process Manager

Spawn, pause, resume, and terminate agent processes. Each agent runs as an isolated unit with its own lifecycle, resource limits, and crash recovery.

M

Memory Bus

Per-process isolated memory with cross-agent shared state. Data persists across executions. Configure persistence per agent — ephemeral or permanent.

T

Tool Router

Register tools once, use them from any agent. Built-in permission enforcement, rate limiting, and error handling. Agents only access tools they declare.

B

Message Broker

Pub/sub channels and direct messaging for inter-agent communication. Typed payloads, message history, and subscriber isolation.

S

Scheduler

Sequential, parallel, race, and conditional execution. Dependency resolution with cycle detection. Retry with fixed or exponential backoff.

E

Observable by Default

Every operation emits structured events. Full execution traces, timing, and error details. Plug in any observability tool and see exactly what your agents are doing.

Quick Start

Running agents in
under 30 seconds.

Define an agent, register it, spawn a process, execute a task. Memory, tools, and messaging are wired in automatically.

app.ts TypeScript
import { Kernel, Agent } from '@llmhut/agentvm'; // 1. Create the runtime const kernel = new Kernel(); // 2. Define an agent with memory + tools const agent = new Agent({ name: 'researcher', handler: async (ctx) => { // Memory persists across executions const count = ((await ctx.memory.get('count')) ?? 0) + 1; await ctx.memory.set('count', count); // Publish to other agents ctx.publish('updates', { topic: ctx.input, run: count }); return `Researched: ${ctx.input} (#${count})`; }, }); // 3. Register, spawn, execute kernel.register(agent); const proc = await kernel.spawn('researcher'); const result = await kernel.execute(proc.id, { task: 'Agentic AI trends' }); console.log(result.output); // "Researched: Agentic AI trends (#1)"

Why AgentVM

What changes.

Without AgentVM With AgentVM
Every framework reinvents process management Shared, battle-tested process lifecycle
Memory is an afterthought (chat buffers) First-class memory bus with isolation
Tools are hardcoded per agent Universal registry with permissions
No inter-agent communication standard Built-in pub/sub and direct messaging
Debugging is guesswork Structured events on every operation
Agents crash with no recovery Clean crash handling, persistent memory

Open Source

Build the future of
agentic AI. Together.

AgentVM is MIT-licensed, community-driven, and building in public. Every design decision is documented. Every RFC is open.

View on GitHub View on npm Join Discord