Features

Why protoAgent

Three ideas, one substrate: a simple core you can actually read, a fully extensible plugin platform, and A2A-native fleet orchestration. Start with a working agent on a fresh clone, grow it into exactly what you need, and run it solo or as a fleet across your machines.

The three ideas

Simple, legible core

You start with a small core you can actually read: the agent runtime, a spec-compliant A2A server, and a handful of keyless tools. Everything else — extra tools, skills, subagents, workflows, memory backends, console views — is opt-in. No inheriting a pile of use-cases you'll never use, then fighting to remove them.

Extensible platform

Grow the agent without forking. Drop-in plugins — installable from a git URL, pinned in a lockfile, shareable as repos — add tools, SKILL.md skills, subagents, workflows, FastAPI routes, managed MCP servers, and their own console dashboards. The core stays lean; you opt into surface area as you need it.

Fleet orchestration

Every protoAgent is a first-class A2A 1.0 server. Agents discover and delegate to one another (delegate_to over a2a / openai / acp), and a single slug-routed console manages the whole fleet — built to run distributed across your machines, not as one monolith on one box.

The features behind them

acp

Drive any coding agent (ACP)

Delegate a real coding job to protoCLI, Claude Code, Codex, or Gemini CLI over the Agent Client Protocol — or run the whole turn on one. protoAgent orchestrates coding agents rather than competing as one.

a2a 1.0

A2A 1.0 as the native interface

protoAgent IS a spec-compliant A2A 1.0 server — HTTP/JSON-RPC, an agent card, and wire extensions (per-turn cost, worldstate deltas, tool calls) carried in the A2A metadata map. A hot-swappable delegate registry fans a sub-task out to other a2a / openai / acp endpoints, so agents discover and delegate to each other over the open standard.

langgraph

Built on LangGraph

The runtime is LangGraph — durable checkpointing, the tool/subagent loop, and the LangChain ecosystem underneath. You extend a graph, not a bespoke loop, so what you learn here transfers.

lean core

A lean core, not a bundle

A small, legible core ships by default; you add the rest as git-URL plugins — pinned in a lockfile, removable cleanly, shareable as repos. A plugin is a full package (tools, skills, subagents, workflows, routes, console views), so you opt in to surface area instead of opting out of it. Lean is measurable, not a vibe: the macOS desktop app is about 100 MB installed — bundled agent server included — and it fetches no runtime at first launch.

extend

Extend without forking

Three opt-in ways to extend a running agent: SKILL.md skills (auto-retrieved into context, even agent-authored), MCP servers (external tools over stdio/HTTP), and plugins (full packages). Shared-runtime fixes land upstream; your domain logic lives in your fork or your plugins.

console

An operator console + custom dashboards

A dedicated React console (and a native desktop app) where a plugin can add its own left-rail dashboard — a Fleet view, a Quant Desk — without a rebuild. Run from chat, manage from surfaces, orchestrate a fleet from one place.

knowledge

Memory, knowledge & skills

A bundled hybrid knowledge store (SQLite FTS5 + embeddings, RRF fusion) the agent reads before every turn, with ingestion for docs / web / audio / video. Skills are retrieved into context automatically and curated over time — the agent can even author its own.

goals

Goals with testable outcomes

Beyond a scheduler: goal mode with pluggable verifiers (a goal is met when a check passes, not when the model says so) and monitor goals for long-horizon, externally-driven targets — e.g. a background loop grinding toward 1M credits, evaluated out-of-band.

telemetry

Built-in cost & latency telemetry

A per-turn telemetry store (cost, p50/p95 latency, tokens, cache-hit, by-model) with CSV export and a retention guardrail — plus first-class Langfuse + Prometheus. Cost and latency visibility is treated as core, not an add-on.

local-first

Local-first & model-agnostic

Powered by your models through an OpenAI-compatible gateway — a local 30B, a hosted frontier model, whatever you point it at. Model choice is gateway config, not code.

headless

Headless, API-first

Run it with no UI (--ui none): A2A + an OpenAI-compatible /v1 endpoint + /metrics. Point any OpenAI client or agent fleet at it. The console is optional, not the product.

sandbox

Sandboxed by design

Optional OpenShell isolation (kernel-enforced filesystem + seccomp + an egress proxy) and a deny-by-default fetch_url host fence — generated from your config, so the blast radius is bounded without hand-writing policy.

Dogfooding

Stress-tested by building on it

We don't just ship the core — we build real agents on it and contribute the patterns back as plugins. A SpaceTraders agent runs an OODA loop on the scheduler (observe every 20 min, escalate to a strategist subagent hourly) toward a standing goal of 1,000,000 credits — with a Fleet dashboard, entirely as plugins that never touch core. A protoTrader Finance plugin adds market data, backtesting, and a gated paper broker. ORBIS (voice companion) connects over A2A to control it by voice. Same substrate, wildly different agents.

Build your agent → Browse plugins Read the docs