GTAF Runtime

GTAF Runtime is TNT Intelligence's enforcement core for delegated action.

It is the layer where governance stops being descriptive and becomes executable: a proposed action enters the runtime together with evaluated governance outputs and context, and the runtime returns a deterministic decision.

Capability is not permission. Proposal is not authority. The runtime is the gate between the two.

The runtime sits on the narrowest and most important line in the system:

This is what gives the runtime strategic weight: it creates a controlled point where external effects can be accepted or refused based on explicit delegation state instead of agent enthusiasm.

The current public runtime contract is easiest to picture as an action request with explicit context:

{
  "scope": "ops.prod",
  "component": "release.agent",
  "interface": "ops-api",

  "action": {
      "name": "git.commit",
      "intent": "release-update"
  },

  "extras": {
      "repository": "payments-service",
      "branch": "release/2026-04"
  }
}

The current public implementation exposes a minimal enforcement API:

from gtaf_runtime import enforce

result = enforce(
  drc=drc,
  context=context,
  artifacts=artifacts,
)

if result.outcome == "DENY":
  raise PermissionError(
      result.reason_code
  )

reason_code = result.reason_code

The point of this example is not the stack itself. The point is that a real system can be wired so that execution permission is evaluated explicitly instead of being inferred from tool access alone.

Many agent systems still blur together planning, tool access, and authority. GTAF Runtime breaks that collapse.

• the planner may propose an action, but it does not authorize it
• the system may see a tool, but that does not imply it may use it

• a denial is not a soft warning; it is the runtime outcome that prevents the effect

• explicit reason codes improve reviewability, debugging, and audit readiness

GTAF Runtime is relevant wherever teams want AI systems to do real work without bypassing governance. Typical collaboration paths include:

• designing the enforcement boundary between AI proposals and external actions

• mapping internal policies, approval logic, and accountability into runtime-ready artifacts

• reviewing whether an existing agent system currently grants too much implicit authority

• shaping language-agnostic runtime contracts for environments that need more than observability after the fact