> 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/getting-started/

::band{size="hero"}
# Get Started

The fastest way to learn Tactus is to clone the examples repo and run procedures that already have embedded specifications.

::band
:::card-grid{columns=2 label="Ways to start"}
:::card{title="Tactus IDE"}
The best way to write, run, and debug agents. Includes a visual interface for human-in-the-loop interactions and a live view of agent execution.

::button{href="/download/" label="Download IDE"}

:::

:::card{title="Command Line"}
Install the CLI, clone `Tactus-examples`, then run specs in mock mode (no API keys) before running against real models.

Editing in VS Code? Install the [Tactus extension](https://marketplace.visualstudio.com/items?itemName=AnthusAISolutions.tactus) for syntax highlighting and code intelligence.

```bash
$ pip install tactus
$ git clone https://github.com/AnthusAI/Tactus-examples.git
$ cd Tactus-examples

# Run the spec suite without API keys (fast, deterministic)
$ tactus test 01-getting-started/01-hello-world.tac --mock

# Docker sandboxing is required by default
# Use --no-sandbox to opt out when isolation is not needed

# Run it for real (requires OPENAI_API_KEY)
$ export OPENAI_API_KEY=your-key
$ tactus run 01-getting-started/01-hello-world.tac
```
:::
:::

## Hello, world (from Tactus-examples)

This is the canonical Hello World example from the `Tactus-examples` repository. It includes an embedded behavior specification so you can test it deterministically in mock mode.

```lua
World = Agent {
  model = "openai/gpt-4o-mini",
  system_prompt = "Your name is World."
}

Specification([[
Feature: Hello World

  Scenario: Greeter returns greeting
    Given the procedure has started
    And the message is "Hello, World!"
    And the agent "World" responds with "Hello! I'm World, nice to meet you!"
    When the procedure runs
    Then the output should fuzzy match any of ["Hello", "Hi", "Hey"] with threshold 0.9
]])

local result = World({message = "Hello, World!"})
return (result and (result.output or result)) or ""
```

Source: [01-getting-started/01-hello-world.tac](https://github.com/AnthusAI/Tactus-examples/blob/main/01-getting-started/01-hello-world.tac) · [How to download and run examples](/examples/)

:::card-grid{columns=2 label="Run it"}
:::card{title="Run it with the IDE"}
1. Download Tactus for your OS from [Download](/download/).
2. Open the app — it includes example procedures ready to run.
3. Open the Hello World example, then press **Run**.
:::

:::card{title="Run it with the CLI"}
1. Install Tactus: `pip install tactus`
2. Clone examples: `git clone https://github.com/AnthusAI/Tactus-examples.git`
3. Run specs without API keys: `tactus test 01-getting-started/01-hello-world.tac --mock`
4. Run for real: `export OPENAI_API_KEY=your-key`, then `tactus run 01-getting-started/01-hello-world.tac`
5. No Docker? Add `--no-sandbox` to the `tactus run` command to opt out explicitly.
:::
:::

## Explore More Examples

Start with the curated examples repo. Each example is designed to be runnable and includes embedded behavior specifications, so you can verify your environment before you spend tokens.

::button{href="/examples/" label="Browse Examples"}

::button{href="https://github.com/AnthusAI/Tactus-examples" label="Examples on GitHub" variant="secondary"}

## Try a project

Use cases are concrete project ideas. If you want a strong first build, start with an embedded copilot and add one or two Human-in-the-Loop checkpoints.

The [Tactus IDE](/download/) includes the standard Human-in-the-Loop components. Use the IDE as a safe playground to experience approvals and structured inputs, then embed the same components in any application.

::button{href="/use-cases/copilot-anything/" label="Read the copilot use case"}

::button{href="/getting-started/projects/" label="Projects to try" variant="secondary"}

Component reference: [Standard Component Library](/resources/components/)

**HITL preview**

::island{name="HitlDemo" demo="getting-started-approval"}

## Docker sandbox by default

The CLI runs procedures inside a Docker sandbox by default and will error if Docker is not available. This prevents accidental non-isolated runs.

If your architecture does not require container isolation for every invocation, opt out explicitly with `--no-sandbox` or set `sandbox.enabled: false` in your config.

When you install from PyPI, the sandbox image builds by installing the matching Tactus version inside the container. When a source checkout is available, the image bakes in the local source instead.

## Prototype supervised, then step back safely

A practical way to automate real work is to start in a supervised interface (Claude Code, Cursor, etc.), then gradually harden what you built into governed procedures. Supervision is a feature while you're exploring—but it becomes a bottleneck if a human must watch every step.

### Prototype (closely supervised)

Start with a Skill and iterate fast while you're watching: the agent has freedom, and you can correct course in real time.

1. Prototype a workflow as an agent Skill.
2. Use MCP servers to connect narrow toolsets like Stripe or Freshdesk; for broad internal APIs, expose one programmable Tactus gateway with focused docs on demand.
3. Tighten the steps until the workflow is boring and repeatable.

::island{name="HitlDiagram" variant="supervised" withStart="true"}

### Step back (asynchronous human checkpoint)

Then harden the workflow into a governed procedure: make data flow predictable, add guardrails, and pause for human input only when needed so the system can run while you're away.

1. Pre-call tools in imperative code when possible (fetch first, then pass results to the model).
2. Add validation, specs, and evaluations so reliability is measurable.
3. Add human checkpoints for high-risk steps so a person stays accountable.

::island{name="HitlDiagram" variant="queued" withStart="true"}

This workflow pairs well with open standards: [Agent Skills](https://agentskills.io/home) for packaging repeatable agent behavior, and [MCP](https://modelcontextprotocol.io/) for connecting tools like Stripe, ticketing systems, and internal APIs. For a small set of unrelated actions, a normal MCP tool catalog is a good fit; for a large application surface, the one-tool Tactus gateway keeps context smaller and lets the agent discover details only when needed.

:::callout{kind="note" title="Case study: Refund ops automation"}
This started as a supervised Skill that processes an Excel file and issues Stripe refunds in sequence. Once it proved useful, it was hardened into a governed procedure: inputs validated up front, tool data fetched deterministically, human checkpoints added for high-risk rows, and an audit trail produced for confidence and compliance.

::button{href="/use-cases/refund-ops/" label="Read the case study"}

::button{href="/use-cases/business-process-automation/" label="Business process automation overview" variant="secondary"}

:::

The goal is not to give a monkey a razor blade and hope for the best. The goal is controlled delegation: let the agent do the repetitive work, and keep humans in charge of the outcomes with full transparency through logging and tracing.

::band
## More learning resources

If you want to go deeper, the books and videos cover the ideas, patterns, and design philosophy behind Tactus.

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

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{tone="muted"}
## Videos

Short walkthroughs and longer deep dives. Start with these two — then browse the rest.

:::card-grid{columns=2 label="Featured videos"}
:::card{title="Why a New Language?"}
*7 min*

The evolution of programming paradigms and why Tactus was created for the age of AI agents.

[Watch](/videos/#why-new-language)
:::

:::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 1 more video on the videos page.

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