# AI Agent Capability Expression Forms: Dedicated Tools, General Executors, and Skills Explained

> Explore AI agent capability expression forms including dedicated tools, general executors, and Skills. Understand trade-offs in cost, flexibility, and maintenance.

- Repository: [Bojie Li/ai-agent-book](https://github.com/bojieli/ai-agent-book)
- Tags: deep-dive
- Published: 2026-08-25

---

**AI agents expose capabilities through three primary forms—dedicated tools, general executors, and Skills—that trade off token cost, flexibility, security, and maintenance overhead.**

The *ai-agent-book* repository by bojieli defines a **spectrum of capability expression forms** that every AI agent architect must navigate. Whether you're building a code assistant, a DevOps agent, or a general-purpose LLM system, the form you choose determines how much context window you burn, how tightly you can control permissions, and how quickly your team can iterate on capabilities.

## Understanding the Three Forms

According to [`book-en/chapter4.md`](https://github.com/bojieli/ai-agent-book/blob/main/book-en/chapter4.md), the spectrum spans from rigid, schema-heavy interfaces to flexible, human-editable workflows. Each form occupies a distinct position on four design dimensions: **token cost**, **security granularity**, **parameter complexity**, and **ease of authoring**.

### Dedicated Tools: Maximum Control, Maximum Tokens

**Dedicated tools** are single-purpose functions with complete JSON Schema definitions. In [`extras/agent-lab/SCHEMA.md`](https://github.com/bojieli/ai-agent-book/blob/main/extras/agent-lab/SCHEMA.md), the book illustrates this with a `deploy_app` tool that requires validated `repo_url`, `environment`, and `version` parameters.

```json
{
  "name": "deploy_app",
  "description": "Deploy an application to the production cluster.",
  "parameters": {
    "type": "object",
    "properties": {
      "repo_url": { "type": "string", "description": "Git repository URL." },
      "environment": { "type": "string", "enum": ["staging","production"] },
      "version": { "type": "string", "description": "Version tag to deploy." }
    },
    "required": ["repo_url", "environment", "version"]
  }
}

```

- **Token cost:** High — every tool's schema consumes hundreds of tokens in the model's system prompt
- **Best for:** Operations requiring fine-grained permission control, audit trails, or complex nested validation

The explicit schema enforcement makes dedicated tools ideal for **sensitive production operations** where you cannot trust the model to generate correct command syntax on its own.

### General Executors: Flexibility Through Abstraction

**General executors** expose a generic interface that accepts arbitrary instructions at call time. The `code_interpreter` tool from the book's examples demonstrates this pattern:

```json
{
  "name": "code_interpreter",
  "description": "Execute arbitrary Python code in a sandboxed environment.",
  "parameters": {
    "type": "object",
    "properties": {
      "code": {
        "type": "string",
        "description": "A self‑contained Python snippet. Return the final expression's value."
      }
    },
    "required": ["code"]
  }
}

```

- **Token cost:** Medium — only the executor's compact schema remains resident; the actual command payload is supplied per-request
- **Best for:** Tasks expressible as code or shell commands where the model's reasoning can generate the needed logic

General executors shift complexity from **schema definition** to **model capability**. A strong model can compute statistics, transform data, or orchestrate systems without needing purpose-built tools for each operation.

### Skills: Human-Editable, Token-Efficient Workflows

**Skills** represent the low-token extreme of the capability expression spectrum. A Skill is a natural-language document—typically [`SKILL.md`](https://github.com/bojieli/ai-agent-book/blob/main/SKILL.md)—describing a multi-step workflow that the agent executes through a general executor.

```markdown

# Deploy Application Skill

**Goal:** Deploy an application from a Git repo.

1. **Clone the repo**  
   ```bash
   git clone {{repo_url}} repo_tmp
   cd repo_tmp
   ```

2. **Build the project**  
   ```bash
   npm run build
   ```

3. **Package the Docker image**  
   ```bash
   docker build -t myapp:{{version}} .
   ```

4. **Push & Deploy**  
   ```bash
   docker push myapp:{{version}}
   kubectl apply -f deploy.yaml --record
   ```

```

- **Token cost:** Low — the catalog entry is just a name and description (dozens of tokens); the full body loads only when needed
- **Best for:** Frequently changing workflows where human editability matters more than machine validation

Parameters like `{{repo_url}}` and `{{version}}` are interpolated by the agent before invoking the underlying `bash` executor. This indirection allows non-engineers to modify operational procedures without touching code.

## Choosing Your Capability Expression Form

The book's analysis in [`book-en/chapter4.md`](https://github.com/bojieli/ai-agent-book/blob/main/book-en/chapter4.md) identifies four design dimensions that should drive your selection:

| Dimension | Dedicated Tool | General Executor | Skill |
|-----------|--------------|------------------|-------|
| **Security & Permissions** | Fine-grained ACLs per operation | Broad sandbox permissions | Inherited from underlying executor |
| **Parameter Complexity** | Deep schema validation with `enum`, `pattern`, nested objects | Simple string or object payloads | Template variables with optional validation |
| **Frequency of Change** | Stable, rarely modified | Stable executor, variable payloads | Frequently updated workflows |
| **Model Capability Required** | Works with weaker models | Requires reliable code generation | Requires strongest models for autonomous execution |

### When to Prefer Each Form

- **Dedicated tools** — Production database writes, infrastructure mutations, financial transactions—any operation where "trust but verify" is insufficient and "verify before execute" is mandatory

- **General executors** — Analysis tasks, data transformations, proof-of-concept capabilities where the overhead of schema maintenance exceeds the risk of model-generated errors

- **Skills** — Runbooks, deployment procedures, customer onboarding flows—any workflow owned by operations teams who need version-controlled, reviewable documents rather than compiled code

## Separating Form from Disclosure Strategy

A critical distinction in the *ai-agent-book* analysis: the **capability expression form** is independent of **how many capabilities the model sees at once**.

- **Form** determines *resident token cost* (what sits in the system prompt) and *parameter-passing semantics*
- **Disclosure strategy** determines *runtime token cost* (loading tools on-demand, indexing, retrieval-augmented generation)

You might choose Skills to keep your system prompt lean, then implement aggressive indexing so only relevant Skills load into context. Conversely, you might embed ten dedicated tools permanently if they're universally needed. Chapter 4's later sections address disclosure strategies separately.

## Summary

The *ai-agent-book* capability expression spectrum gives architects explicit vocabulary for a tradeoff every AI agent faces:

- **Dedicated tools** trade token budget for security and validation
- **General executors** amortize token cost across unlimited operations
- **Skills** minimize resident tokens while maximizing human editability

Your choice should be driven by security requirements, parameter complexity, change frequency, and the capability of your underlying model—not by defaulting to the most explicit or most flexible option.

## Frequently Asked Questions

### What is the difference between a Skill and a general executor?

A **general executor** is a tool with a fixed, generic interface (like `code_interpreter` accepting any Python string). A **Skill** is a markdown document describing a workflow that runs *through* a general executor—providing human-readable structure without expanding the token budget. The executor is the mechanism; the Skill is the content.

### Why not use dedicated tools for everything?

Dedicated tools carry **high token costs**—each schema consumes hundreds of tokens in the model's context window. For agents with dozens of capabilities, this crowds out conversational history and reasoning space. As implemented in [`book-en/chapter4.md`](https://github.com/bojieli/ai-agent-book/blob/main/book-en/chapter4.md), the spectrum exists precisely because "one size fits all" wastes resources where flexibility suffices.

### How do I decide between a general executor and a Skill?

Use a **general executor** when the model generates the operation logic on the fly (e.g., "calculate this statistic"). Use a **Skill** when humans need to specify or modify the procedure (e.g., "deploy following these exact steps"). Skills add indirection and template processing overhead that general executors avoid.

### Can I mix forms in the same agent?

Yes—most production agents should. The *ai-agent-book* presents the spectrum as **complementary options**, not mutually exclusive categories. Stable, sensitive operations warrant dedicated tools; exploratory analysis uses general executors; rapidly evolving procedures become Skills. The art is matching each capability to its appropriate expression form.