> Beyond prompts + hope: Tactus is a language + runtime for safe, reproducible tool-using agents—give them tools and a procedure, with approvals, durability, and the principle of least privilege.

Canonical: https://tactus.anth.us/ai-engineers-toolbox/

::band{size="hero" eyebrow="Learn"}
# The AI Engineer’s Toolbox

Agents are not useful because they talk. They’re useful because they *do work*. Tools are where AI meets the real world — files, APIs, databases, deployments — and where “toy demo” becomes a real system.

::band
## Contents

1. [Tools are capabilities, not callbacks](#tools-are-capabilities)
2. [Schema-first interfaces (typed I/O)](#schemas)
3. [Inspectable tool use (what happened?)](#inspectable)
4. [Deterministic orchestration (agent proposes, code decides)](#determinism)
5. [Least privilege and staged tool access](#least-privilege)
6. [Reliability: specs, checkpoints, and safe retries](#reliability)

### Tools are how agents touch reality {#tools-are-capabilities}

In many frameworks, tools are “just functions you register.” That’s fine in a prototype, but in production it becomes a trap: arbitrary callbacks and side effects are hard to reason about, hard to test, and hard to secure.

**In Tactus, tools are explicit capabilities: schema-first, inspectable, and controllable.**

- **Schema-first** inputs so the model can’t hand-wave arguments
- **Deterministic implementations** so “doing work” is reliable and testable
- **Control surfaces** so you decide which tools exist and when they’re available

::island{name="AnimatedAIEngineersToolboxDiagram"}

This is the core pattern: agents propose; deterministic code enforces; tools do work. It’s the difference between “ask the model nicely” and “build a system you can deploy.”

## Schema-first interfaces (typed I/O) {#schemas}

A tool’s schema is not documentation — it’s a boundary. It’s where you define what the model is allowed to ask for, what your system will accept, and what “valid” means.

:::aside
In the Tactus DSL, tools have explicit input fields (with types, defaults, and descriptions). Procedures also declare typed inputs and outputs. That structure makes it easier to:

• validate inputs before execution\
• validate outputs after execution\
• generate safer UI/CLI forms\
• reduce “stringly typed” glue code
:::

When you treat schemas as executable boundaries, you get more than type safety: you get a place to enforce policy, prevent misuse, and make workflows legible to humans.

## Inspectable tool use (what happened?) {#inspectable}

Production systems fail in boring ways. The hard part is diagnosis: what did the agent do, and why? Tactus treats tool calls as first-class events you can inspect (e.g., whether a tool was called, the last arguments, and the last result).

This matters for debugging, yes — but it’s also a reliability and safety tool. If you can’t tell whether a “send” step happened, retries become terrifying. If you can inspect tool calls, you can build idempotency guards and safe re-entrancy.

## Deterministic orchestration {#determinism}

The biggest mindset shift for tool-using systems is separating what the model is good at from what software is good at.

:::aside
Use the agent for synthesis: drafting, planning, classification, and turning messy inputs into structured proposals.

Use deterministic code for control: validation, policy, staging, retries, and irreversible actions.
:::

Tactus supports directly invoking tools from procedure code as well — which gives you deterministic control over when a tool runs, without involving the model at all. That makes “do the work” composable and testable.

## Least privilege by design {#least-privilege}

Tactus enforces least privilege across multiple dimensions: minimal toolsets (only what's needed), curated context (relevant information, not everything), network isolation (networkless by default), API boundaries (secretless broker), and temporal gating (capabilities unlock at the right stage).

The safest tool is the one the agent doesn't have—and the safest credential is the one it never touches. This is how you build bounded autonomy: the workflow can run on its own for long stretches, and it can still be safe when it reaches a step that needs real side effects.

In plain terms, it’s like letting a burglar into an empty building: even if an attacker gets into the runtime, there’s nothing valuable inside to steal.

## One Tool For Everything

For broad application surfaces, a long list of tiny MCP tools can become its own reliability and context-budget problem. Tactus supports a different pattern: expose one programmable tool, inject a host-provided module, let the model ask for focused docs when needed, and then write a small governed snippet that composes your app’s APIs.

Read the pattern: [One Tool For Everything](/use-cases/one-tool-programmable-api/).

## Reliability: specs, checkpoints, and safe retries {#reliability}

Tooling is the interface to reality — and reality is messy. The path to semi-unattended operation is not “better prompting.” It’s guardrails: durable checkpoints, human-in-the-loop gates, and behavioral specs you can test.

This page is intentionally marketing-forward. If you want the precise DSL semantics and tool patterns, the canonical reference is the Tactus specification and the tools chapters in Learning Tactus.

::band{columns="cta"}
## Ready to Start Building?

::button{href="/getting-started/" label="Get Started" size="lg"}
