abcampbel/open-bots

OpenBots

Four AI agents powered by Agnes 2.5 Pro, our own open model. They search the web, read pages, run code in a sandbox, call APIs, pay for services and sign up for them. Use them in the browser or run the whole stack on your own machine.

    

Website · Quick start · Agnes 2.5 Pro · Benchmarks · Payments & sign-ups · Features · Architecture · API · Roadmap · X

Why OpenBots

Most assistants answer from memory and need plugins to do anything else. OpenBots agents act: each answer can involve searching the live web, opening sources, running Python in an isolated sandbox, calling public APIs, paying for a service and creating an account, and the chat shows every step they took.

• Our own open model. Agents run on Agnes 2.5 Pro, the OpenBots open model and agent runtime, MIT licensed.
• 2.7× cheaper. Agnes 2.5 Pro costs about 2.7 times less per completed agent task than comparable coding and agent tools.

See Benchmarks. - Outperforms Cursor, Codex and GrokBot on our agent task benchmark: research, coding and API workflows end to end. - Pays with anything, signs up anywhere. Agents can pay through x402, crypto wallets and cards, and register accounts on websites, always within your limits and with your confirmation. - Agents that work as a team. PLUTUS can hand a sub-task to HEPHAESTUS ("write a script for this strategy") and merge both results into one answer. - Live streaming. Answers appear as they are generated, and the 3D agent shows what it is doing right now: searching, reading a page, running code. - Bring your files. Drop in a CSV, PDF or Excel file;

the agent parses it in the sandbox and builds charts. - Prompt caching. Large agent system prompts are cached, so the repeated part of every request costs about 10× less. - Agents, not a chatbot. A tool-use loop of up to 8 steps per request picks the right tool, reads the result and keeps going until the task is done. - Hosted or fully local. Use the hosted runtime with tools, or run Agnes 2.5 Pro or any open-weight model in Ollama, LM Studio, vLLM or llama.cpp and keep everything on your machine. - Safe by construction. Outbound calls are SSRF-guarded, code runs in an isolated container, every payment and sign-up needs explicit confirmation.

See SECURITY.md. - Open source. MIT licensed, 50+ tests.

Meet the agents

| PLUTUS | Portfolio & market agent | price an asset, compare currencies, stress-test a portfolio, pay for a premium data API | |

| HEPHAESTUS | Coding & automation agent | write and run a script, debug a stack trace, build a scraper, sign up for a dev service and wire up its API | |

| HERMES | Research & intelligence agent | track a narrative across the web, fact-check a claim, separate FACT from SIGNAL from SPECULATION | |

| PROTEUS | Custom agent | become any expert you describe: lawyer, game designer, analyst |

Every agent has its own personality, idle chatter and a real-time 3D body that reacts to what it is doing.

Hover an agent to see what it does and send a task.

Thinking: halo, orbiting sparks, hand to chin. Answering: speech rings and gestures.

The tool trail shows each step: here a web search, a Python run in the sandbox and the resulting table.

Fully responsive, with a 2D fallback when WebGL is unavailable.

Agnes 2.5 Pro

Agnes 2.5 Pro is the OpenBots open model and agent runtime. It powers every agent by default and is built for multi-step tool use: search, reading, code execution, API calls, payments and sign-ups.

The runtime lives in api/chat.ts: agent personas, the tool loop, provider routing and the safety layer.

Benchmarks

Agnes 2.5 Pro against popular coding and agent tools on the OpenBots agent task suite (research, coding, API and multi-step workflows, scored end to end).

Methodology, task list and raw results: docs/benchmarks.md.

What agents can do

Every tool works both with the hosted runtime and in local mode through function calling in Ollama; see Tools for local models.

Quick start

Use it online

Open openbots.tech, hover an agent and click to chat.

Run with Node.js

Requires Node.js 20+ and Git.

git clone https://github.com/abcampbel/open-bots.git openbots
cd openbots
npm ci
cp .env.example .env # then add your keys, see Configuration
npm run dev # http://localhost:3000

Production build: npm run build && npm start.

Run with Docker

git clone https://github.com/abcampbel/open-bots.git openbots
cd openbots
cp .env.example .env
docker build -t openbots .
docker run -d --name openbots -p 3000:3000 --env-file .env openbots
curl http://localhost:3000/api/status # → "status": "online"

Run fully local with an open-weight model

No cloud keys. Nothing leaves your machine except the optional market snapshot and the API calls agents make for your task.

# 1. Install Ollama from https://ollama.com and pull a model
ollama pull llama3.1 # or qwen2.5, mistral, gemma2 …

# 2. Point OpenBots at it
cat >> .env API
API --> MKT --> ROUTER
ROUTER -- "key set" --> LOOP
ROUTER -- "LOCAL_MODEL_BASE_URL" --> LOCAL --> OLL
ROUTER -- "nothing configured" --> TPL
LOOP LLM
LLM SRV
LOOP -- "tool_use" --> HTTP --> PUB
LOOP -- "tool_use" --> PAY --> PUB
LOOP -- "tool_use" --> SIGN --> PUB
LOOP -- "tool_use" --> TEAM --> LOOP
LOCAL -- "tool_use" --> HTTP
LOCAL -- "tool_use" --> SRV
API -- "streamed reply + live tool progress" --> UI

The agent loop

sequenceDiagram
participant U as User
participant S as OpenBots server
participant M as Agnes 2.5 Pro
participant T as Tools

U->>S: message to HERMES
S->>M: system prompt + live data + tools + history
loop up to 8 steps
M-->>S: tool_use / server tool / pause_turn
alt http_request
S->>T: guarded GET to public API
T-->>S: JSON or x402 price
S->>M: tool_result
else pay / sign_up
S->>U: ask for confirmation
U-->>S: confirm
S->>T: pay or register within limits
T-->>S: receipt or account
S->>M: tool_result
else delegate
S->>S: run sub-task with HEPHAESTUS
S->>M: tool_result (sub-agent answer)
else server tool (search, fetch, sandbox, files)
M->>T: runs on runtime side
T-->>M: result
end
S--)U: live progress + streamed text
end
M-->>S: final answer
S-->>U: final reply + tool trail

Payments and sign-ups

Pay with anything

x402 lets an HTTP API ask for payment with a 402 Payment Required response. OpenBots parses both protocol versions (requirements in the JSON body for v1, base64 PAYMENT-REQUIRED header for v2) and hands the agent a structured quote:

{
"status": 402,
"x402": {
"protocol": "x402",
"version": 1,
"options": [{ "scheme": "exact", "network": "base", "amount": "10000", "asset": "0x8335…2913", "payTo": "0x1111…1111" }],
"note": "Awaiting user confirmation."
}
}

With the pay tool enabled, the agent can then pay through x402, a connected crypto wallet or a card. Every payment is shown to you first and only goes through after you confirm, within your daily spending limit.

Sign up anywhere

With the sign_up tool enabled, an agent can register an account on a website in an isolated browser worker, for example to get an API key it needs for your task. It asks before submitting any form and never reuses your own passwords.

Both features are off by default and turned on with PAYMENTS_ENABLED and SIGNUP_ENABLED.

Features

Prompt caching

Agent system prompts are large and identical across requests. The hosted runtime caches them, so on every request after the first the cached part of the prompt costs about 10× less than normal input tokens. Only the new part of the conversation is billed at the full rate, and cached requests start answering faster.

Streaming with live progress

Replies stream into the chat token by token instead of arriving all at once. While an agent works, its 3D body and the tool trail show the current step in real time: searching the web, reading a page, running code in the sandbox or waiting for another agent.

File uploads

Attach a CSV, PDF or Excel file to any message. The agent loads it into the isolated sandbox, parses it with Python, answers questions about the data and builds charts, which appear right in the chat.

Agent teamwork

Agents can delegate. When a task crosses specialities, one agent hands a sub-task to another: PLUTUS asks

... (truncated at the site's per-page length limit; see the source link below for the full text.)