Everything about running an agent you own

What agentd is, who it is for, and where to start for your role.

The problem agentd solves, the principles behind it, and how it compares.

The shapes teams deploy — jobs, reactive daemons, pipelines, triage, agent teams — with examples.

The protocols, model providers, platforms and standards agentd works with.

How agentd contains an agent: no ambient tools, killable reasoning, approvals, audit.

Short answers to the questions evaluators and newcomers ask most.

An eleven-agent software company run by two people, worked end to end.

agentd as the init of a custom Linux for robots, appliances and kiosks.

The install script, release downloads, the container image, the npm clients and source builds.

A first agent against a real model, a tool from an MCP server, then a daemon you attach to.

Write, validate and run a durable workflow — then kill it mid-run and watch it resume.

A pair-programming daemon on your repository, with approvals and a budget.

Typed decisions, decision guards and per-turn routing, on a support-ticket workflow.

Connect OpenAI, Anthropic, Bedrock, Azure, Vertex, local servers and decision models.

Pick the model for each job: turns, thinking, decisions, triage, approvals, routing.

Token windows, lifetime caps, degrade models and per-run limits.

Declare MCP servers, authenticate to them, scope their tools, and verify the connection.

Act when something changes: resource subscriptions, MCP Events, webhooks and streams.

Write an agent as one Markdown document, preview what the model reads, and ship it.

Triggers, data flow, fan-out, waits, guards and resilient remote calls, by example.

Approvals, asks and human gates, and who can answer them.

Diagnose a refused config, a stalled run, a failed connection or a model error.

Hand bounded work to narrowed child agents and collect their results.

Expose an agent over A2A, sign people in, and delegate to other agents.

Run agentd as a job, under systemd, or on Kubernetes.

Drain, pause, resume, cancel and reload a running daemon.

Logs, health probes, Prometheus metrics, OTLP traces and alerts.

Carry more work per instance, then spread it across replicas safely.

The terminal and web clients: attach, sign in, follow, approve, steer.

Serve the web UI from your own domain, and what the daemon must allow.

A security checklist turned into a validated, hardened configuration.

Credentials for model providers, MCP servers and A2A peers: static, OAuth, AWS, SPIFFE.

Give an agent its own signed identity for AAuth-protected MCP servers.

Build your own client on A2A and the extensions agentd declares.

Build your own binary on agentd-core, with tools written in Rust.

One binary, two kinds of process: how a run flows from configuration to result.

The supervisor that never talks to the model: process tree, kill ladder, recovery.

One turn end to end: context, model rounds, tool calls, termination.

One runtime, no modes: how jobs, daemons and triggers fit together.

Durable step graphs: the run lifecycle, the scheduler, and when a graph beats a conversation.

One reviewable file that defines an agent, and what a document may and may not declare.

Model kinds, providers and roles, fallback, structured generation and routing.

Where tools and context come from, and how agentd connects to MCP servers.

How people and agents reach a running agentd: principals, conversations, tasks and the card.

Delegation as a process tree, and the trust boundary between parent and child.

The threat model, the containment guarantees, and their limits.

Layers, precedence, validation before side effects, secrets and hot reload.

Validation first, exit codes as an API, and telemetry you can filter.

Why Rust, the dependency discipline, and what the choices cost.

Every configuration path: type, default, flag, environment variable and reload class.

Instruction-document syntax, every directive kind, and the document-writable keys.

Every workflow node kind: fields, outputs and a sample.

Templates, durations, statuses, limits and validation rules for workflows.

Every flag, environment variable, subcommand and exit code.

Every log event and metric agentd emits.

Cargo features, the release feature set, and the crates.

The terms the documentation uses, defined in a sentence or two.

What changed in each release of agentd.

What agentd sends to each model wire, and how it reads the answer.

MCP revisions, capabilities, negotiation and the events agentd logs.

The A2A listener: routes, methods, errors, limits and card fields.

The extensions agentd declares on top of A2A 1.0, and how a client activates them.

The typed command DataPart: how a client runs an operation agentd declares.

The observation feed a display client follows: frames, ordering and resume.

The facts agentd attaches to an A2A task for a client to render.

The A2A JSON-RPC binding on a unix socket, where the kernel vouches for the caller.