FollowAgents AI AGENTS DIRECTORY
Home / AI Agent Glossary / Agent-Computer Interface (ACI)
Core Concepts

Agent-Computer Interface (ACI)

Also called: ACI

An agent-computer interface (ACI) is how a tool, API, or environment is designed to be used by an AI agent rather than a human — optimized for machine parsing and predictable structure instead of visual layout.

AgentTool / OS / AppACI layerDesigned for machine parsing, not human eyes
The ACI layer shapes how an agent and the tool it operates communicate.

Most software interfaces — a web page, a CLI's help text, an app's UI — are designed for a person to read and click through. When an AI agent is the one operating a tool instead, some of those design choices stop being helpful: a busy visual layout doesn't matter to something that doesn't have eyes, but an inconsistent output format or an error message that assumes a human will figure out what went wrong absolutely does matter, because the agent has to parse and act on that output programmatically.

Agent-computer interface (ACI) is the term for designing that surface — the tool definitions, the output format, the error messages — specifically for an agent to consume, the way 'human-computer interface' design optimizes for a person. Concretely this tends to mean: consistent, structured output (so the agent doesn't have to guess at parsing); clear, actionable error messages (so the agent's next step can actually respond to what went wrong, rather than just retrying blindly); and tool descriptions written for what a model needs to decide when and how to call them, not for what a person browsing documentation needs.

Good ACI design matters because an agent's overall reliability is often bottlenecked less by the language model's reasoning and more by whether the tools it's given return something it can actually use — a powerful model calling a poorly designed tool can still fail the task if the tool's output can't be reliably parsed or its errors don't say what's actually wrong.

How it works

The diagram shows the ACI layer sitting between an agent and whatever it's operating — a tool, an OS, or an app — as the thing that shapes how they communicate. Unlike a human-facing UI, this layer is designed for machine parsing rather than human eyes: predictable formats, explicit error states, and descriptions written for a model deciding which action to take next.

Example

A file-search tool built with ACI in mind might return a consistent JSON structure with a clear error field and a specific reason code when no matches are found, rather than a human-friendly but ambiguous message like 'nothing here!' that an agent would have to guess how to interpret.

How it differs

ACI is related to tool-manifest and function-tool-calling but describes a broader design principle rather than a specific format: a tool manifest and function-calling schema are concrete mechanisms an agent uses to discover and invoke a tool, while ACI is the general idea that the whole surface — including error messages and output structure, not just the calling convention — should be designed for a model to consume.

Common misconceptions

Often assumed: ACI just means giving an agent a tool manifest or API schema.
Actually: A schema is one part of it, but ACI also covers things like error message clarity and output consistency — a tool can have a technically valid schema and still be hard for an agent to use reliably if its outputs are inconsistent or its errors are vague.
Often assumed: If an interface works well for a human developer, it will also work well for an agent.
Actually: Human-friendly design often prioritizes things (visual layout, terse messages a person can infer meaning from) that don't help an agent, which needs explicit, consistently structured output it can parse programmatically.

FAQ

What is an agent-computer interface (ACI)?
It's how a tool, API, or environment is designed to be used by an AI agent instead of a human — optimized for consistent, machine-parseable output and clear error messages rather than visual layout.
How is ACI different from a tool manifest?
A tool manifest is a specific mechanism for describing a tool to an agent; ACI is the broader design principle that the tool's entire surface, including its output and error messages, should be designed for a model to consume.
Why does ACI design matter for agent reliability?
Because an agent's success often depends less on the model's reasoning and more on whether the tools it calls return something it can reliably parse and act on.

Last checked: 2026-08-28

Related terms

Function Calling / Tool Calling

Function calling (also called tool calling) is a model capability where the model can output a structured request to invoke a specific function with specific arguments, instead of only producing free-form text.

Tool Manifest

A tool manifest is the structured description of a tool — its name, what it does, and what arguments it expects — that gets included in a model's context so it knows the tool exists and how to call it.

MCP

MCP (Model Context Protocol) is an open standard that lets AI applications connect to external tools, data, and prompts through one consistent interface instead of a custom integration for each.