> 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/learn-more/

::band{size="hero"}
# Learn More

Deep-dive articles that explain how to give agents tools, keep them safe with guardrails, and measure their reliability.

::band
## Guiding Principles {#learn-guiding-principles}

Tactus is opinionated on purpose: close the loop with verifiable iteration, shift left to catch errors early, and use layered guardrails so agents can do real work safely.

::button{href="/guiding-principles/" label="Read: Principles"}

::band{tone="muted"}
## The Tactus Book Series {#learn-books}

Three complementary books: learn the patterns, dive into the reference, or keep the cheat sheet on your desk.

:::card-grid{columns=3 label="Books"}
:::card{title="Learning Tactus"}
![Learning Tactus cover](/assets/books/learning-tactus.png)

A coherent introduction: the why, the mental model, and the core patterns.

[Read](https://anthusai.github.io/Learning-Tactus/) · [PDF](https://anthusai.github.io/Learning-Tactus/pdf/Learning-Tactus.pdf) · [Repo](https://github.com/AnthusAI/Learning-Tactus)
:::

:::card{title="Programming Tactus"}
![Programming Tactus cover](/assets/books/programming-tactus.png)

The reference: a deeper and broader tour of the language.

[Read](https://anthusai.github.io/Programming-Tactus/) · [PDF](https://anthusai.github.io/Programming-Tactus/pdf/Programming-Tactus.pdf) · [Repo](https://github.com/AnthusAI/Programming-Tactus)
:::

:::card{title="Tactus in a Nutshell"}
![Tactus in a Nutshell cover](/assets/books/tactus-in-a-nutshell.png)

A quick reference for when you’re writing and debugging.

[Read](https://anthusai.github.io/Tactus-in-a-Nutshell/) · [PDF](https://anthusai.github.io/Tactus-in-a-Nutshell/pdf/Tactus-in-a-Nutshell.pdf) · [Repo](https://github.com/AnthusAI/Tactus-in-a-Nutshell)
:::
:::

::band
## The AI Engineer’s Toolbox {#learn-toolbox}

A marketing-forward perspective on tool design: schema-first capabilities, inspectable tool calls, programmable gateways, context-efficient discovery, and staged access.

::button{href="/ai-engineers-toolbox/" label="Read: Toolbox"}

::island{name="AnimatedAIEngineersToolboxDiagram"}

::band
## Guardrails for Agent Autonomy {#learn-guardrails}

Tactus gives you levers of control at every level: capability, context, network, and human oversight. You don't hope for safety—you engineer it.

::button{href="/guardrails/" label="Read: Guardrails"}

::island{name="AnimatedGuardrailsStackDiagram"}

::band
## Validation {#learn-validation}

Procedures declare typed inputs and outputs, validated with Pydantic. This isn't just decoration: it's a contract that guarantees type safety at the edges of your agentic workflows.

::button{href="/validation/" label="Read: Validation"}

::band
## Model Primitive {#learn-model-primitive}

A stateless prediction interface for training, inference, and evaluation. Clean contracts, versioned models, and reliable outputs.

::button{href="/model-primitive/" label="Read: Model Primitive"}

::band
## Agent Primitive {#learn-agent-primitive}

A stateful, tool-using runtime for multi-turn reasoning. Guardrails turn autonomy into shippable behavior.

::button{href="/agent-primitive/" label="Read: Agent Primitive"}

::band{tone="muted"}
## Videos {#learn-videos}

Watch the story: visuals + narration that mirror the articles.

:::card-grid{columns=2 label="Featured videos"}
:::card{title="Guardrails for Agent Autonomy"}
Why constraints enable autonomy: staged tools, human gates, and a secretless broker boundary (so there’s nothing in the runtime to steal).

[Watch](/videos/#guardrails)
:::
:::

Plus 2 more videos on the videos page.

::button{href="/videos/" label="Watch videos"}

::band
## Sandboxing & Isolation {#learn-sandboxing}

Agents run in a Lua sandbox inside a networkless container, constraining what they can touch and firewalling side effects. Privileged operations are brokered by a separate process that holds the secrets. It’s like letting a burglar into an empty building: even if the agent is compromised, there’s nothing valuable inside to steal—and nowhere to send it.

::button{href="/guardrails/#sandboxing" label="Read: Sandboxing"}

::island{name="ContainerSandboxDiagram"}

::band
:::callout{kind="tip" title="Why do we need a new language?"}
We have Python. We have TypeScript. We have powerful agent frameworks. But they were built to manipulate deterministic logic, not probabilistic behavior.

**Why a New Language? (7 min)**

::video{src="https://dt8dmvzuiunkp.cloudfront.net/videos/why-a-new-language.mp4" title="Why a New Language?" poster="https://dt8dmvzuiunkp.cloudfront.net/videos/why-new-language-poster.jpg"}

::button{href="/why-new-language/" label="Read: Why a New Language?"}

:::

::band
## Behavior Specifications {#learn-specifications}

Tactus treats behavior specs as part of the language itself: inline with procedures, executable by the runtime, and tied directly to evaluations so reliability stays visible as your system changes.

::button{href="/specifications/" label="Read: Specifications"}

::island{name="SpecificationsDiagram"}

::band
## Evaluations {#learn-evaluations}

One successful run is luck. Reliability is a statistic. Evaluations let you measure accuracy, cost, and reliability performance across datasets so you can ship with confidence.

::button{href="/evaluations/" label="Read: Evaluations"}

::island{name="EvaluationsDiagram"}
