Open Source · MIT Licensed

Build Autonomous AI Agents

An open-source framework for creating agents that discover tasks, execute them, and self-heal. 10 lines of code. Zero dependencies.

npm install@zoobicon/agents

Ship an agent in minutes

Here is a complete uptime monitor agent. It discovers URLs to check, pings them on a schedule, and reports results — all in one file.

uptime-monitor.tstypescript
import { createAgent } from "@zoobicon/agents";

const monitor = createAgent({
  id: "uptime-check",
  name: "Uptime Monitor",
  scheduleIntervalSec: 300,
  discover: async () => [
    { url: "https://mysite.com" },
    { url: "https://api.mysite.com/health" },
  ],
  execute: async (input) => {
    const res = await fetch(input.url);
    return {
      output: { status: res.status, up: res.ok },
      confidence: 1,
    };
  },
});

await monitor.run();

Everything you need for production agents

Batteries included, but every piece is replaceable.

Task Discovery

Agents find their own work. Define what to look for, the framework handles scheduling and deduplication.

Confidence Scoring

Every execution returns a confidence score. Auto-execute when confidence is high, flag for review when low.

Retry & Self-Heal

Exponential backoff, configurable retries. Agents recover from failures automatically without intervention.

Pluggable Storage

InMemory for testing, PostgreSQL for production. Bring your own storage backend with a simple interface.

Skills Marketplace

Extend agents with community-built skills. Like npm for AI capabilities. Install, compose, and share.

Event System

Subscribe to agent events. Build dashboards, alerts, and integrations with hooks for every lifecycle stage.

How it works

A simple loop: discover, execute, store, emit. Failures retry automatically.

discover()
    │
    ▼
 [tasks]  ──────►  execute(task)
                        │
                        ▼
              ┌─── success? ───┐
              │                │
             yes              no
              │                │
              ▼                ▼
     { output,          retry with
       confidence }      backoff
              │                │
              ▼                └──► (max retries → fail event)
       store results
              │
              ▼
       emit events
  (dashboard, alerts, hooks)

How we compare

Zoobicon Agents is built for the serverless era — minimal surface area, maximum flexibility.

FeatureZoobicon AgentsOpenClawAutoGPT
Setup time2 minutes30+ minutes1+ hours
RuntimeServerless (Vercel/AWS)Local processLocal process
LanguageTypeScriptTypeScriptPython
Dependencies0 (core)ManyMany
StoragePluggable (Postgres/Memory)Markdown filesVector DB
LicenseMITMITMIT
GitHub StarsNew163K170K
Enterprise hostedYes (Zoobicon)NoNo

Don't want to run your own infrastructure?

Zoobicon Agents Cloud runs your agents 24/7 with managed cron, dashboards, alerts, and team collaboration.

Managed schedulingReal-time dashboardEmail / Hash alertsSkills marketplaceTeam accessSOC 2 infrastructure
Starting at $19/monthFree tier available · No credit card required

Quick Start

From zero to a running agent in under five minutes.

1

Install

npm install @zoobicon/agents
2

Create an agent

import { createAgent } from "@zoobicon/agents";

const agent = createAgent({
  id: "my-agent",
  name: "My First Agent",
  discover: async () => [{ task: "hello" }],
  execute: async (input) => ({
    output: { message: "Hello from agent!" },
    confidence: 1,
  }),
});
3

Run it

await agent.run();
// Agent discovers tasks and executes them
4

Add scheduling

const agent = createAgent({
  id: "scheduled-agent",
  name: "Scheduled Agent",
  scheduleIntervalSec: 300, // every 5 minutes
  discover: async () => [ /* ... */ ],
  execute: async (input) => { /* ... */ },
});
5

Add persistence

import { PostgresAgentStore } from "@zoobicon/agents/stores";

const store = new PostgresAgentStore(process.env.DATABASE_URL);

const agent = createAgent({
  id: "persistent-agent",
  name: "Persistent Agent",
  store, // results survive restarts
  discover: async () => [ /* ... */ ],
  execute: async (input) => { /* ... */ },
});
6

Deploy anywhere

# Works on Vercel, AWS Lambda, any Node.js server
vercel deploy

# Or run as a long-lived process
node agent.mjs