Get Started

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

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.

Download IDE

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 for syntax highlighting and code intelligence.

$ 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.

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 · How to download and run examples

Run it with the IDE

Download Tactus for your OS from Download.
Open the app — it includes example procedures ready to run.
Open the Hello World example, then press Run.

Run it with the CLI

Install Tactus: pip install tactus
Clone examples: git clone https://github.com/AnthusAI/Tactus-examples.git
Run specs without API keys: tactus test 01-getting-started/01-hello-world.tac --mock
Run for real: export OPENAI_API_KEY=your-key, then tactus run 01-getting-started/01-hello-world.tac
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.

Browse Examples Examples on GitHub

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 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.

Read the copilot use case Projects to try

Component reference: Standard Component Library

HITL preview

Approve sending this message? (Tool: send_message)

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.

Prototype a workflow as an agent Skill.
Use MCP servers to connect tools like Stripe, Freshdesk, and internal APIs.
Tighten the steps until the workflow is boring and repeatable.

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.

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

This workflow pairs well with open standards: Agent Skills for packaging repeatable agent behavior, and MCP for connecting tools like Stripe, ticketing systems, and internal APIs.

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.

Read the case study Business process automation overview

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.