# AIP-1: Purpose & Process > The mission of the AIP registry, the lifecycle every AIP follows, and how to propose, review, and finalize a new spec. --- # AIP-2: AIP Template > The template every new AIP starts from. Copy this file, change the frontmatter, and fill in the sections. --- # AIP-3: SKILL.md — skill manifest format > A markdown + frontmatter format for distributing reusable agent skills as portable, version-controlled files. --- # AIP-4: DESIGN.md — design token format & registry conventions > A markdown + frontmatter format for portable design tokens, and the registry conventions used by designkit.sh to share community kits. --- # AIP-5: CANVAKIT.md — template + data-source binding > A markdown + frontmatter format for templates that declare named data sources, resolve them in parallel, and re-render when data changes. --- # AIP-6: COMPANY.md — agentcompanies/v1 (company, role & objective primitives) > A filesystem-first, vendor-neutral file format for representing AI companies — their org structure, roles, and objectives — as portable git-native packages. --- # AIP-7: GOVERNANCE.md — agentgovernance/v1 (audit, approval & policy primitives) > A filesystem-first format for recording approvals, append-only audit logs, and autonomy policies as workspace files — vendor-neutral, third-party-verifiable. --- # AIP-8: AGENCY.md — agentagencies/v1 (autonomous agency engine) > A filesystem-first operations format that extends agentcompanies (AIP-6) and agentgovernance (AIP-7) with the doctypes needed to run an autonomous agency — services, procedures, engagements, agreements, deliverables, invoices. --- # AIP-9: OPERATOR.md — agentoperators/v1 (operator runtime protocol) > A single canonical operator shell — pluggable profile, skills, tools, memory, governance — that any agent runtime can implement and any conforming workflow can dispatch to. --- # AIP-10: KNOWLEDGE.md — agentknowledge/v1 (LLM-maintained wiki) > A filesystem-first knowledge-base format where an LLM curates, links, and lints a markdown wiki on top of immutable raw sources, turning agent knowledge into a compounding artifact instead of a per-query retrieval miss. --- # AIP-11: LESSON.md — agentlearning/v1 (distilled lessons from experience) > A markdown format for storing the transferable lessons an agent extracts from successful and failed runs — title, trigger, evidence, outcome — and a contract for how runtimes distill them and inject them back into future turns. --- # AIP-12: PLAYBOOK.md — agentplaybooks/v1 (evolving prompt overlays) > A markdown format for prompt-overlay fragments that ride on top of an operator's persona, plus a contract for how runtimes evolve them via reflective deltas without violating locked persona traits. --- # AIP-13: WORK.md — agentwork/v1 (projects, initiatives, tasks) > A filesystem-first work-item format with a unified scope vocabulary that makes containment, applicability, and ownership three orthogonal axes — usable across the whole agentproto family. --- # AIP-14: TOOL.md — agenttool/v1 (abstract agent contract) > A markdown + frontmatter format for declaring a single agent tool's abstract contract — its identity, input/output schemas, side-effect profile, approval class, and resource budget. Pairs with the standard `defineTool` signature any implementation exposes. Implementation-specific concerns (transport, code, runner, auth, sandbox) live on the AIP-30 DRIVER layer. --- # AIP-15: WORKFLOW.md — agentworkflow/v1 (abstract orchestration manifest) > A markdown + frontmatter format for declaring a multi-step agent workflow's abstract orchestration shape — its steps, branching, parallelism, approval gates, suspend/resume, and compensation. Pairs with the standard `defineWorkflow` / `defineStep` signatures. Implementation lives entirely in the per-step TOOL.md contracts and their AIP-30 DRIVER bindings; workflows themselves are pure orchestration data. --- # AIP-16: IO.md — shared input/output schema blocks > A composable schema block defining `inputs`, `outputs`, `inputsFiles`, and `outputsFiles` — the data-shape primitives reused by every manifest format that needs to declare what flows in and out of a runnable unit. --- # AIP-17: RUNNER.md — shared process boundary block > A composable schema block defining the `runner` field — engine (in-process / subprocess / sandbox), optional container image, declarative dependency needs, and resource limits — reused by every manifest format that runs code. Permissions (secrets, network) and IO are defined elsewhere; this block scopes only to the process boundary. --- # AIP-18: COLLECTION.md — collections/v1 (typed collections + items) > A composable primitive pack that lets any AIP define domain-extensible item types as on-disk schema files (`COLLECTION.md`) instantiated by markdown records (`ITEM.md`), so future workspace AIPs (work, knowledge, companies) compose on a shared type system instead of inventing their own. --- # AIP-19: SECRETS.md — secret inventory + reveal contract > A workspace-level manifest format for declaring secret slugs, their purpose, access grants, and audit metadata — without ever storing the values themselves. Hosts resolve slugs against a real vault at reveal time. --- # AIP-20: WORK.md — agentwork/v2 (typed coordination workspace on AIP-18 collections) > A workspace-only successor to AIP-13 that drops hardcoded project/initiative/task doctypes and delegates all per-item-kind schema work to AIP-18 collections — owning only the workspace root manifest, scope axes, status rollups, and cross-AIP composition. --- # AIP-21: AGENCY.md — agentagencies/v2 (commercial agency workspace on AIP-18 collections) > A workspace-only successor to AIP-8 that drops the eleven hardcoded agency doctypes (service, engagement, agreement, deliverable, invoice, counterparty, procedure, pricing-model, routine, capacity, agency) and delegates all per-doctype schema work to AIP-18 collections — owning only the workspace root manifest, the engagement lifecycle helpers that span collections, scope axes, and cross-AIP composition with strong governance and work bindings. --- # AIP-22: OFFICE.md — agentoffice/v1 (operating workspace for org-level coordination) > A live operating workspace for an organisation — declares which collections (roles, objectives, departments, teams, policies) are tracked, the org-tree containment, reporting hierarchy, and cross-AIP composition with governance, work, knowledge, and agency. Distinct from AIP-6's static company profile (companies.sh community standard). --- # AIP-23: IDENTITY.md — agentidentity/v1 (layered identity workspace on AIP-18 collections) > A workspace AIP that defines layered, composable agent identity — typed layers as AIP-18 collections, confidence-scored items, optional temporal entries, and compression-artifact tiers — owning only the workspace root manifest, layer registry, compression policy, junction rules, and cross-AIP composition. --- # AIP-24: ASSEMBLY.md — agentassembly/v1 (multi-agent collective workspace — council, voting, peer, hierarchy) > A workspace AIP for multi-agent collectives. Unifies four collaboration patterns — council (advisory overlay), voting (quorum decision body), peer (network of equals), and hierarchy (reporting tree) — under one doctype, with synthesis rules, locked traits, and audit policy as first-class workspace concerns. --- # AIP-25: PERSONA.md — agentpersona/v1 (face / character / voice carrier) > A single-doc markdown + frontmatter format for portable agent personas — the public face, voice register, backstory, and boundaries of a character — sibling to AIP-23 IDENTITY (heavy substance) and building block of AIP-24 ASSEMBLY. --- # AIP-26: CODE.md — code-workspace + sources composition > A composable schema block defining the `code` and `run` fields that declare what files compose a runnable bundle (inline, local, github, ref) and how to invoke them — together with the `code-workspace` first-class kind that other manifests reference. --- # AIP-27: REF.md — agentref/v1 (composable reference primitive) > A composable reference primitive — `ref` values that point at files, URLs, identities, transactions, and other resources via a typed, registry-extensible discriminated union with a canonical compact string form. Replaces ad-hoc `kind:slug` strings, narrow per-AIP path encodings, and string-typed identity bindings with one shared shape that other AIPs import. --- # AIP-28: INTENT.md — agentintent/v1 (user-facing operation manifest) > A markdown + frontmatter format for declaring a user-facing agent intent — the verb a user surfaces ("create image", "list PRs"). Sits between SKILL (multi-step expertise) and TOOL (atomic technical call), carrying the catalog/UX layer (label, intent, surfaces, examples) and routing one or more underlying tools, with the standard `defineIntent` entry-point signature. --- # AIP-29: CLI.md — agentcli/v1 (CLI integration manifest) > A markdown + frontmatter format for declaring a command-line tool's surface to an agent — its binary, install paths, version detection, subcommand tree, sandbox needs, auth flows, and output conventions. Lets agents discover, install, and safely operate third-party CLIs (gh, gcloud, kubectl, ffmpeg, …) inside a sandbox, with the standard `defineCli` entry-point signature. --- # AIP-30: DRIVER.md — agentdriver/v1 (abstract driver supertype) > A markdown + frontmatter format for declaring a concrete implementation of one or more agent tools — its identity, kind (cli / http / mcp / sdk / builtin), install lifecycle, auth surface, sandbox profile, and per-tool dispatch bindings. The supertype every concrete driver AIP (CLI, HTTP, MCP, SDK) specialises, with the standard `defineDriver` entry-point signature. --- # AIP-31: HTTP.md — agenthttp/v1 (HTTP driver specialisation) > A markdown + frontmatter format for declaring an HTTP-API driver — its base URL, per-tool endpoint/method/body templates, header bindings, response extraction, and (when needed) streaming hints. Specialises AIP-30 DRIVER for the `kind: http` case. Most third-party APIs (OpenAI, Stripe, Replicate, Anthropic) wrap as HTTP drivers. --- # AIP-32: MCP.md — agentmcp/v1 (MCP driver specialisation) > A markdown + frontmatter format for declaring a Model Context Protocol driver — its server reference, transport (stdio / SSE / HTTP), per-tool MCP tool-name binding, prompts/resources composition, and lifecycle. Specialises AIP-30 DRIVER for the `kind: mcp` case. Wraps Anthropic-spec MCP servers (filesystem, github, postgres, …) as agent tools. --- # AIP-33: SDK.md — agentsdk/v1 (in-process SDK driver specialisation) > A markdown + frontmatter format for declaring an in-process SDK driver — an npm/pip/cargo/go package that exposes named functions implementing one or more abstract TOOL contracts directly in the host runtime, without subprocess spawn or network hop. Specialises AIP-30 DRIVER for the `kind: sdk` case. --- # AIP-34: WORKSPACE.md — agentworkspace/v1 (workspace identity manifest) > A markdown + frontmatter format for declaring a workspace's identity — globally addressable id, owner, storage choice, defaults, publish posture. The root manifest of every AIP-organized workspace; pairs with STORAGE.md (AIP-35) for the storage policy block. --- # AIP-35: STORAGE.md — agentstorage/v1 (storage policy block) > A composable schema block defining the `storage` field — provider, config, sync semantics, auth ref, exclude rules — for any manifest that names a backing store. Reused by WORKSPACE.md (AIP-34) and any future manifest that names persistent state. Inline or ref, mirroring AIP-17 RUNNER and AIP-19 SECRETS. --- # AIP-36: SANDBOX.md — agentsandbox/v1 (compute environment policy block) > A composable schema block defining the `sandbox` field — provider, config, command env, network egress, resource limits — for any manifest that names a compute environment for agent-issued shell commands. Sibling primitive to STORAGE.md (AIP-35); inline or ref, mirroring AIP-17 RUNNER and AIP-19 SECRETS. --- # AIP-37: LIFECYCLE.md — agentlifecycle/v1 (event vocabulary) > A vocabulary AIP defining the standard lifecycle event names that hosts fire and that policy blocks (storage sync, sandbox lifecycle, etc.) reference. Not a runtime — just a shared language so configs across hosts mean the same thing. --- # AIP-38: POLICY.md — agentpolicy/v1 (composable policy block) > A markdown + frontmatter format for declaring policy on a resource — access grants (who can perform which actions), defaults (per-block behavioural defaults), limits (rate / quota caps), and requirements (cross-cutting must-haves like MFA / approval). Composable inline | ref | file. Granted on AIP-39 ACTION ids — implementations / TOOLs are decoupled from policy. --- # AIP-39: ACTION.md — agentaction/v1 (verb primitive) > A markdown + frontmatter format for declaring an abstract verb / operation that can be performed on a resource — its identity, semantics, side-effect profile, approval class, and lifecycle events. The pivot primitive that TOOL implements (with LLM schema), POLICY references (for grants), INTENT routes to (from user verbs), and WORKFLOW steps invoke. Bottom-up — implementations declare which actions they implement. --- # AIP-40: EXTENSION.md — agentextension/v1 (custom doctype declarations) > A meta-doctype that lets a workspace declare its own custom doctype as an extension of an existing AIP — adding fields, tightening constraints, overriding defaults, and choosing a path convention — without going through the public AIP process. The runtime (@agentproto/manifest verbs, MCP server, scaffolder) treats local extensions identically to public AIPs. --- # AIP-41: ROUTINE.md — agentroutine/v1 (recurring schedule + target) > A markdown + frontmatter format for declaring a recurring or event-driven invocation of an action, workflow, or tool. Decouples "when" (the schedule) from "what" (the target). Supports cron / interval / calendar / manual / event-driven schedules, with retry, jitter, catchup policy, identity attribution, and failure routing. --- # AIP-42: AGENT.md — agentagent/v1 (base runnable agent primitive) > A markdown + frontmatter format for declaring a runnable agent — composes identity, persona, model, tools, actions, skills, workflows, runner, memory, governance, policy, and routines into a single manifest. Standalone runnable in any AIP-9 OPERATOR-conforming runtime. Body is the system prompt. Operators (AIP-9) extend AGENT with organizational context (role, company binding, dynamic per-request resolution). --- # AIP-43: REGISTRY — agentregistry/v1 (handle catalog primitive) > A primitive that catalogs N defineX'd doctype handles for runtime lookup. Operations (register / get / list / lookup), identity rules, capability metadata namespace, discovery hooks. Hosts use it to assemble per-host provider/backend/tool catalogs without re-implementing the registry shape; the same primitive works for any doctype family. --- # AIP-44: ACP.md — agentacp/v1 (Agent Client Protocol profile) > An agentproto profile of the upstream Agent Client Protocol (agentclientprotocol.com) that defines how agentproto operators (AIP-9) participate in ACP — both as clients driving subprocess agents and as servers exposed to ACP-speaking IDEs (Zed, VSCode, JetBrains, Cursor). Pins the upstream protocol revision, layers governance/audit hooks, and standardises operator-binding extensions under metadata.aip44.*. --- # AIP-45: AGENT-CLI.md — agentcli-interactive/v1 (interactive agent CLI manifest) > A markdown + frontmatter format for declaring an interactive agent CLI — a long-running, bidirectional, agent-as-process binary like Hermes Agent, Claude Code, OpenCode, Goose, or Gemini CLI — and how to install, spawn, and converse with it. Layers over AIP-29 (CLI.md) for install/version/auth blocks and AIP-44 (ACP.md) for the session/wire model when protocol=acp; falls back to MCP or proprietary protocols via a discriminator. --- # AIP-46: AGENT-SESSIONS — agent-session-lifecycle/v1 (long-running multi-turn agent orchestration) > A generic session-management protocol for orchestrating long-running, multi-turn agent CLIs (Hermes, Claude Code, OpenCode, …) on a host. Standardises the lifecycle (spawn → multi-turn → kill), the data model (sessions[] with status / cwd / workspace bindings), the over-the-wire surface (HTTP + SSE + MCP tools), and the workspace-resolution pattern that lets a single host serve many bound directories. Layers over AIP-45 (AGENT-CLI) for the per-adapter spawn semantics and AIP-44 (ACP) for the wire format inside one turn. --- # AIP-47: ROLE.md — agentrole/v1 (organizational role manifest) > A single-doc markdown + frontmatter format for portable organizational roles — mission, responsibilities, capabilities, tools, KPIs, seniority, reporting line, lifecycle hooks. Sibling to AIP-25 PERSONA (face) and AIP-23 IDENTITY (substance); referenced by AIP-9 OPERATOR (`role:` field) and AIP-6 COMPANY (`roles//ROLE.md` doctype). Roles describe what a job is — independent of who holds it (persona/identity) and which instance is hired (operator). --- # Driver family > The DRIVER family — AIP-30 abstract supertype plus its concrete subtypes (CLI, and the planned HTTP/MCP/SDK). Catalog page that groups related AIPs whose ordinal proximity isn't enforced by monotonic numbering. The family is the navigation surface; numbers are identifiers. --- # Agent Protocol > Open numbered standards for the AI-agent ecosystem. Filesystem-first; markdown is the program. Specifications for what agents are, what they remember, what they do, and what they're allowed to do — composable across runtimes. --- # Propose an AIP > How to submit a new Agent Improvement Proposal — submission workflow, editorial process, review timelines, number assignment, and what makes an AIP land. --- # Related Standards & Initiatives > The peer specifications, foundations, and ecosystems the Agent Protocol registry defers to, builds on, or runs adjacent to. AIPs are not built in isolation — they live in the gaps these initiatives leave. ---