How AGX works

Automated guardrails for AI agents.

AGX tests which guardrails hold up against evidence before they reach production. AGX Lite then enforces the approved guardrails at runtime, before an agent changes workflow state.

Four-layer execution stack

Evidence, testing, enforcement, and agent work stay separate.

This separation lets agents move work forward while AGX dictates what is actually allowed.

Operational Data Ingestion

Connect your existing systems to a standardized data schema

AGX does not require custom data pipelines. It ingests fragmented records from ERP, CRM, PSA, warehouse, and event logs, then maps them into clean structured fields.

Output: clean operational data ready for analysis and replay.
Policy Generation and Historical Replay

Generate, shadow-test, and tune safety guardrails

AGX analyzes agent execution traces to find failure patterns. LLMs draft candidate guardrails, then AGX replays those rules against historical data, rejects weak rules that create false positives, and tunes thresholds.

Output: validated safety policies, or rejected drafts.
Real-Time Policy Enforcement

Evaluate the live case before workflow state changes

AGX sits directly in the critical path of your existing workflow. Before an agent takes action, AGX evaluates the case against active guardrails and returns a deterministic decision: allow, block, needs_evidence, or review_required. Degradation behavior is explicit: fail open, fail closed, or force review.

Output: real-time governance for Temporal, ServiceNow, SAP, or similar systems.
Bounded Agent Execution

Let agents do only the permitted work

Once a policy is approved, agents operate strictly inside the control boundary. They can prepare review packets, request missing evidence, route exceptions, and update workflow state, but only when AGX has cleared the action.

Output: autonomous work, safely contained.
Product boundary

AGX tests. AGX Lite enforces.

The architecture separates expensive evidence work from the millisecond runtime decision. That keeps analysis rigorous and enforcement simple.

AGX

Before production

Discovers process signals, reconstructs workflow paths, tests bounded controls against history, and runs shadow pilots when the downstream path is uncertain.

Approved control bundle, evidence packet, and rollout decision.
AGX Lite

Inside production

Loads the approved control bundle, receives prefetched evidence and a live event, then returns a deterministic pre-action decision without calling models or source systems.

allow, needs_evidence, review_required, or block.
Historical analysis Yes No
Control discovery Yes No
AI model calls Only outside enforcement Never
Live decision path Exports the approved bundle Evaluates the action
Workflow testing

Testing complete workflows, not just isolated rules.

A real recovery path is rarely one rule. Billing leakage, for example, requires evidence completeness, rate-card checks, scope recovery, approval state, and finance authority to work together. AGX tests the entire governed path.

The composition

Evidence completeness + rate-card match + scope recovery + approval status

AGX turns these pieces into one governed Billing Readiness Gate.

The test

Replay the composed gate against history

AGX checks whether the gate reduces leakage without creating unmanageable review burden or slowing down cycle times.

The result

The agent applies the tested path

The agent can monitor, package, and follow up because AGX has already tested the combined controls and enforcement has authorized the next step.

The compounding asset

The Rejected Policy Ledger makes the engine smarter.

Most systems track what worked. AGX treats rejected policies as first-class assets because knowing what does not work prevents the engine from repeating mistakes.

Rejected Policy Ledger

Every failed candidate records exactly why it failed: increased cycle time, policy violation, weak evidence, bad cohort fit, or too many false positives. Those failures become reusable constraints for the next search.

The long-term asset is not agent chatter. It is a growing, auditable map of guardrails that worked, failed, narrowed, or need revalidation.
Where AI fits

Drafting vs. deciding.

AGX keeps LLM work separate from guardrail validation, replay, statistical testing, and inline enforcement. AI drafts and explains; deterministic systems decide what is allowed.

Drafting LLM Maps messy language into testable guardrails

Translates unstructured logs and stakeholder frames into structured safety policies for the engine to test.

Operational LLM Handles bounded follow-up

Drafts owner questions, classifies replies, and prepares packets only inside an enforced guardrail.

Advisor LLM Explains the evidence and audit trail

Links decisions to source evidence, replay results, rejected policies, and audit records.

Deterministic Engine Runs replay, testing, and inline gates

Uses symbolic logic, statistical testing, and state machines to decide whether a guardrail can be promoted or enforced.

Hard system boundaries

If a requirement is missing, the agent does not guess.

AGX downgrades, blocks, asks for evidence, or sends the guardrail back for revalidation.

No claim without mapped data

AGX cannot claim leakage, risk, or improvement unless source records map cleanly to the data schema and pass quality checks.

No recommendation without an owner

Every generated policy must name the operating decision it changes and the accountable human owner.

No action without policy validation

An agent may execute only when policy, role, approval, and system boundaries validate the action.

No promotion without testing

A guardrail cannot move from sandbox to live enforcement unless it survives historical replay and live canary testing with measurable outcome improvement.

No execution without a sealed audit chain

Evidence state, guardrail logic, policy result, owner decision, agent work, and final outcome must be reconstructable for audit.

Start with one guardrail worth testing.

Pick one agent action or workflow checkpoint where failure would cost money, delay work, or create audit risk. AGX will map the evidence, shadow-test the candidate guardrail, and show whether it should be enforced.

Start diagnostic → Operational data mapped · Guardrails shadow-tested · Agents bounded