Agents

A self-hosted, observable agent orchestrator for running multi-agent workflows on your repos.

Build and take ownership of your agentic universe. Create your agents and compose them with skills, memory, and triggers: repo events/labels, cron, or inter-agent dispatch.

The daemon schedules each agent and runs the AI CLI (Claude Code, Codex, or your own local LLM) inside a fresh ephemeral runner container. Agents work through your repo host's native primitives: issues, PRs, reviews, comments. GitHub MCP tools are preferred; gh is available in the runner as fallback for complex local checkout/test/PR loops. GitHub today; GitLab under discussion.

Get started

See docs/quickstart.md to get the daemon running on a repo in a few minutes from the published ghcr.io/eloylp/agents image. For five import-ready fleet scenarios (solo coder, coder + reviewer, autonomous fleet, local LLM, multi-repo) see config_examples/.

Features

• Three ways to interact with your agent fleet:
  • Web dashboard: graphical. Design the fleet from the graph-first workflow designer, manage agents, prompts, skills, repos, dispatch edges, and trigger bindings; watch the live event firehose, agent traces with tool-loop transcripts, and memory viewer.
  • MCP server: conversational. Control agents and trigger runs straight from Claude Code in your terminal (or Cursor, Cline, or any MCP client).
  • REST API: programmatic. Scriptable from any HTTP client; the dashboard itself runs on top of it.
• Reactive inter-agent dispatch: agents invoke each other at runtime with depth, fanout, and dedup safety limits.
• Observable: See the full event chain in realtime from the UI, from events to runners to traces that will facilitate your prompt tuning journey.
• Self-hosted: your code and prompts stay on your infrastructure. No SaaS dependency.
• Security recommendations: ships built-in guardrails prepended to every agent prompt for indirect prompt-injection resistance, public-action discretion, daemon-only memory scope, and GitHub repository tool usage (MCP first, gh fallback).
• Daemon auth: create the first local admin user from the root login page, use an HttpOnly browser session for UI access, manage additional users, and create revocable named bearer tokens for MCP/API clients.
• Multi-backend: pick Claude, Codex, or a custom backend per agent. Different agents in the same fleet can use different providers.
• Discovery and diagnostics: the daemon detects backends and tools, validates CLI health, and persists discovery snapshots.
• Local-model support: run any agent through llama.cpp, Ollama, vLLM, or any OpenAI-compatible endpoint. The daemon ships a built-in Anthropic-to-OpenAI translation proxy so the existing claude CLI works unchanged against your own LLM (experimental).
• One agent model, many triggers: label events, cron schedules, GitHub event subscriptions, on-demand API calls. Same agent, wired however you want.
• Composable skills: reusable guidance blocks (architecture, security, testing, DX, ...) composed into agents by stable public catalog reference.
• Scoped, versioned reusable catalogs: prompts and skills can be global, workspace-scoped, or repo-scoped; guardrails are global or workspace-scoped and are selected per workspace. APIs and imports expose stable public refs, while SQLite uses opaque internal IDs for FK integrity. Edits publish immutable versions so traces can record the exact prompt, skill, and guardrail text used for each run. Humans can select prompts with readable scope paths such as global, default, or default/eloylp/agents.
• Token budgets and leaderboard: daily/weekly/monthly UTC calendar token caps, enforced before each run. Global scopes cover all workspaces; simple repo, agent, and backend scopes apply across workspaces by name, while workspace+repo, workspace+agent, and workspace+backend isolate caps to one workspace. NavBar alert banner when any budget crosses its alert threshold. Per-agent leaderboard tracks total and average token consumption per run. Full CRUD via dashboard, REST, and MCP.
• SQLite-backed: state lives in a SQLite database, managed through the three interfaces above. config.yaml is an optional export/import format for reusable prompts/skills/guardrails and workspace-local agents/repos, not a runtime dependency.

How it works

Every run, regardless of trigger, goes through the same pipeline:

1. Compose the prompt: workspace guardrails + skills + selected prompt + runtime context + memory.
2. Start a runner container from the configured agents-runner image, configure the operator-provided git identity, and spawn the AI CLI (claude, codex, or your local model) with JSON-schema-enforced output and repository tools available inside that container.
3. Parse the structured response: artifacts, dispatch requests, updated memory.
4. Persist the trace, fan out any dispatches, write back memory.

Read docs/mental-model.md before writing your first prompt; the rest of the docs assume you have the model. For the daemon's package layout and how a request flows through the Go code, see docs/architecture.md.

Security

Security is the operator's responsibility; this project ships defaults and recommendations to start from, not guarantees. See docs/security.md for the threat model, what the daemon does and does not protect against, and the additional controls operators should layer for production. Vulnerability disclosure: SECURITY.md.

Contributing

Both human and agent contributions are welcome: issues, PRs, doc fixes, prompts, ideas. The autonomous fleet picks up issues and PRs labeled ai ready (the maintainer's opt-in signal); everything else is reviewed and merged by humans. See CONTRIBUTING.md for the full flow and docs/architecture.md for the Go package layout and how a request flows through it.