Learning Tactus

Secretless Execution: Brokers, Tool Runners, and Trust Boundaries

Container isolation is a huge step forward: it keeps an agent from vandalizing your laptop and it makes filesystem side effects ephemeral by default.

But from an information security perspective, containers don’t automatically solve the most important question:

Where are the secrets?

If your runtime (container or process) contains OPENAI_API_KEY, SMTP credentials, database tokens, or cloud keys, then prompt injection and tool misuse can still become data exfiltration.

This chapter is about the guardrail that InfoSec teams love because it changes the game:

Make the runtime secretless.

When there’s nothing to steal, a whole class of attacks collapses.

Current Status: The Brokered Sandbox Runtime

Tactus’s “brokered sandbox runtime” changes the default local security posture:

In local development, the default uses sandbox.broker_transport: stdio, which means the runtime container does not need networking to talk to the broker.

If you run with a remote broker (for example, to explore cloud/Kubernetes-style deployment), you can use sandbox.broker_transport: tcp (or tls). In that mode the runtime needs network access (sandbox.network != none), so you rely on infrastructure controls (egress policies/security groups) to ensure the runtime can only reach the broker.

Roadmap: From Brokers to Full Tool Runners

The brokered runtime is the MVP step toward a more complete execution model:

What works today:

What’s intentionally not done yet:

The Core Idea: Treat the Runtime as Untrusted

By design, a Tactus procedure mixes:

The architectural goal is to make the boundary between those explicit and enforceable.

In practical terms:

This is a trust-boundary story, not a prompt story.

A Reference Architecture (Conceptual)

Here’s a common deployment shape:

  1. Runtime (untrusted): executes .tac code, runs agent turns, stores state/checkpoints, renders HITL requests.
  2. Broker (trusted): holds credentials and performs privileged operations (model calls, credentialed tools).
  3. Tool runners (mixed): execute tool code in different trust zones depending on risk.

You can picture the trust boundary like this:

             +------------------------------+
             |          TRUSTED             |
             |  Broker + credential store   |
             |  - model provider keys       |
             |  - SMTP / DB / internal APIs |
             +---------------+--------------+
                             |
                             | narrow RPC/tool interface
                             |
 +---------------------------v---------------------------+
 |                        UNTRUSTED                      |
 | Runtime container (per execution)                     |
 | - Lua VM + procedure orchestration                    |
 | - state/checkpoints                                   |
 | - NO secrets                                          |
 | - restricted filesystem/network                       |
 +-------------------------------------------------------+

Two properties are doing most of the security work here:

This is the principle of least privilege made concrete: remove ambient authority from the untrusted runtime, and force privileged work through narrow, auditable interfaces.

Pattern: One Tool For Everything

A host application can expose one programmable tool instead of a large catalog of separate MCP tools. The tool runs a short Tactus snippet inside the sandbox, and the host provides an application module. Generic hosts often ask snippets to import that module explicitly with require("your_app").

Plexus is a real example of this pattern at application scale. It exposes one MCP tool, execute_tactus, and injects plexus as a global host module so snippets can skip the import boilerplate:

local catalog = plexus.api.list({})
local score = plexus.score.info({ id = "compliance-score" })

return {
  score_name = score.scoreName,
  namespaces = catalog,
}

That injected module is the capability grant. Plexus decides what the module exposes, how calls are authenticated, which operations require human approval, how budgets are enforced, and how traces and async handles are recorded. The MCP client sees one compact, self-documenting tool instead of a context-heavy catalog; the agent can ask for focused API docs when it needs them. Since Tactus also has Agent as a first-class primitive, the submitted snippet can call a bounded sub-agent when the task needs an agentic investigation loop.

A Key Trust Boundary: .tac Code vs .tac.yml Config

Tactus draws a sharp line between sandboxed procedure code and trusted configuration:

If you accept user-contributed procedures, accept .tac files. Treat sidecar .yml as code review territory.

Volume Mounting: Sharing Files with Procedures

By default, Tactus mounts your current directory to /workspace:rw inside the container, making it easy for procedures to read and write project files. This design choice balances convenience with safety:

Why it's safe:

Accessing files from Lua code:

-- Read a file from your project
local content = File.read("/workspace/data.txt")

-- Write results back to your project
File.write("/workspace/output.json", result_json)

-- List files in your project
local files = File.list("/workspace")

Mounting external data: If your procedure needs to access files from outside the current directory (like a sibling repository or shared data directory), use a sidecar configuration file:

# my_procedure.tac.yml
sandbox:
  volumes:
    - "../other-repo:/workspace/external:ro"  # Read-only access to sibling repo
    - "/data/shared:/data:ro"                  # Read-only shared data

Disabling the default mount: For procedures that should have limited filesystem access (like output-only workflows or untrusted procedures), you can disable the automatic current directory mount:

# restricted_procedure.tac.yml
sandbox:
  mount_current_dir: false  # Disable default mount
  volumes:
    - "./output:/workspace/output:rw"  # Only mount output directory

When to disable the default mount:

The volume mounting system is an example of Tactus's trust boundary philosophy: .tac procedure files are sandboxed and safe to share, while .tac.yml sidecar files are trusted configuration that control what the procedure can access.

Applying It to the Running Example

In Part II, our workflow can draft and send a recap email (stubbed). In production, “send email” is exactly the kind of step that wants to live behind a trusted boundary:

With a secretless runtime:

At the .tac level, the workflow stays readable and high-level. The security posture comes from execution boundaries.

Tool Runners as Trust Zones

Not all tools are equal. Some are pure computation (safe). Some are side-effectful (dangerous). Some require secrets (sensitive).

The direction is a runner model where tool execution happens in different trust zones. A useful mental model is to define “runner” modes:

The point isn’t the exact taxonomy; it’s that you treat tool execution as part of your threat model and choose a trust zone intentionally.

In practice, you often want multiple boundaries at the same time. For example: you might want to run tool code in an isolated environment (to protect the host and avoid cross-run leakage), while still keeping credentials out of the agent runtime entirely. That’s what the broker boundary enables: the runtime stays secretless, and privileged operations happen behind a narrow, auditable interface.

A practical rule of thumb

Preserving Streaming and Developer Experience

Security boundaries often fail adoption because they make development painful.

Tactus is designed so isolation doesn’t mean “black box execution.” You still want:

The broker boundary can preserve streaming by forwarding tokens/events rather than forcing the runtime to “poll” for results. Conceptually:

  1. runtime asks broker to execute a model call
  2. broker streams tokens back over the same channel
  3. runtime records the stream in the trace and forwards it to the UI

This matters for credibility: if your security model requires a totally different execution mode in production than in development, you won’t get parity—and parity is how you avoid security regressions.

Auditability and Policy Enforcement

Brokers and runners aren’t just about hiding secrets. They also give you places to enforce controls that are hard to bolt on later:

From an InfoSec perspective, this is moving from “best effort” controls to enforceable policy.

Multi-Tenant Isolation (Why Per-Execution Matters)

If you ever want to run agent workflows for multiple users, you need to prevent information linkage between sessions. Common failure modes include:

The combination of:

…is how you build a multi-tenant story that security professionals can support.

The goal is not “agents can never do anything dangerous.” The goal is:

Looking Ahead

At this point, we have strong guardrails:

Next, we switch from “don’t let it do something dangerous” to “make sure it reliably does the right thing”: behavior specifications and evaluations.