ACP Spec v0.1

ACP (Agent Context Protocol) is a structured URI-based protocol for defining instructions between large language models (LLMs), tools, memory contexts, and DAG-based planners. It is optimized for agent systems, orchestration, and real-time reasoning.

🌐 URI Scheme

ACP (Agent Context Protocol) introduces a custom URI scheme to standardize how execution targets, models, tools, and planner graphs are represented within distributed agent networks. These URI-based identifiers ensure a structured, interpretable, and interoperable format for defining agent-based operations, enabling seamless execution of tasks across multiple contexts.

1. Why Use a Custom URI Scheme?

ACP’s URI scheme provides a universal addressing mechanism that allows agents, tools, and models to be referenced and executed dynamically. This approach offers:

✔️ Interoperability: A unified format for referencing execution targets across different LLMs, tools, and memory stores.
✔️ Standardization: A structured way to define computation nodes in agent workflows.
✔️ Extensibility: Future-proof design to support additional capabilities like multi-agent collaboration, graph-based execution, and memory persistence.

2. General ACP URI Format

The general structure of an ACP URI is:

{category}://{target}/{parameters}

Where:

{category} → Specifies the type of execution (e.g., memory, llm, tool, vector).
{target} → Identifies the specific model, tool, or agent executing the request.
{parameters} → Optional query-like parameters that modify execution behavior.

⚙️ Key Features

Supports real-time and DAG execution of LLM + tools
Built-in session memory and context chaining
Planner supports conditions, fallback, and streaming
Traceable and visualizable graph output
Multi-model auto-routing and interoperability

1. Instruction URI Types

llm://<model>[.memory]:<prompt>
Calls a local or remote LLM, optionally prepended with memory if .memory is specified.
tool://<toolName>:<param>
Executes a built-in or external tool (e.g., search, calculator).
plan://instruction;instruction;...
Execute plans as DAGs (Directed Acyclic Graphs).

🔸 LLM Call

llm://model:prompt — Executes a prompt against a named LLM.

llm://mistral:Generate a sci-fi story about Mars

🔸 LLM with Memory

llm://model.memory:prompt — Attaches past memory context from the session into the LLM prompt.

llm://mistral.memory:Continue our conversation

🔸 Tool Invocation

tool://name:input — Runs a tool plugin registered by name, passing the input string.

tool://search:best books on systems thinking

🔸 ACP Planner Graph

plan:// — Executes a DAG of instructions, with optional conditions and chaining.

plan://
    A=llm://mistral:Give me a startup idea;
    B=llm://mistral.memory:Summarize it in one line;
    C=tool://search:B;
    B<-A;
    C<-B;

🔸 Conditional Nodes

Supports conditional routing via ?contains:value or ?else.

plan://
    A=llm://mistral:Flip a coin;
    B=llm://mistral:You said heads!;
    C=llm://mistral:You said tails!;
    D=llm://mistral:Fallback message;
    B<-A?contains:heads;
    C<-A?contains:tails;
    D<-A?else;

2. Execution Rules

Topological Sort: DAG nodes execute respecting dependencies.
Conditionals: Branches can specify ?contains:<keyword> or ?else.
Parallelism: Nodes without dependency conflict execute concurrently.
Memory: Outputs from each node are stored per session and retrievable via .memory flag.
Traceability: All execution steps are captured in a trace object.

ACP: Agent Context Protocol v0.1 (Draft)