Skip to content
TruCore logoTruCore

Infrastructure for the Agent Economy

TruCore builds the backbone for autonomous AI agents

ProvenGraph helps an agent determine what to trust. TruCore ATF determines what that agent is authorized to do. Together they provide a trust and control layer between AI reasoning and real-world execution.

Every TruCore product is open source, MIT-licensed, and built for developers who want their agents to transact and discover without human intervention.

Built for agent developers, protocol teams, and AI infrastructure builders.

Products

Open-source infrastructure for AI agents

Every product is MIT-licensed. Self-host for free, or use our managed cloud when you need scale.

Featured Product

Agent Transaction Firewall

Deterministic policy enforcement for AI agent transactions. Every decision produces a cryptographic receipt. Built for Solana trading bots and autonomous agents.

Every decision is enforced before execution. Every result produces a cryptographic receipt. You can verify it independently.

Live API enforcement on Solana. Every policy decision creates a verifiable receipt. Status reflects real system state.

Last updated: 2026-08-31

Golden Path

Try ATF in Four Commands

From first trade to verified receipt. No manual config needed.

atf - golden path demo
$

Open your terminal and install the CLI globally:

npm install -g @trucore/atf@1.5.1

The demo runs each atf command live. Run them yourself in your terminal. No project setup required.

Each command produces operator-friendly terminal output and bot-ready JSON with machine_summary, suggested_action, and suggested_command fields.

Enforcement Model

What ATF Enforces

Spend Caps

Max SOL or token spend per tx and per window.

Protocol Allowlist

Jupiter, Orca, and Raydium (swaps). Solend, Marginfi, and Kamino (lending). Perps venues feature-gated, off by default.

Slippage Bounds

Hard max slippage and minimum-out checks.

TTL + Nonce

Permits expire fast and cannot be replayed.

Activation

Make Your First Protected Trade

You can test ATF safely before using real funds.

No setup required for demo. No risk to try.

Step 1: Run a sample transaction using demo or dry-run.

Step 2: Review the decision and receipt to understand policy and output.

Step 3: Run your own protected trade with real or controlled input.

You stay in control. You can start in safe mode with no real execution.

Start Your First Protected Trade

How It Works

First Protected Trade, Step by Step

Every trade follows the same enforced path: policy evaluated, decision made, receipt generated, result verified.

AI Agent

submits tx intent with policy permit

Policy Gate

  • ·spend cap
  • ·allowlist
  • ·slippage
  • ·ttl + nonce

Intelligent Probe

risk scan · PIL

Execute

on-chain settlement

Receipt

sealing…

▸ Agent submits transaction intent

Intelligence

Policy Intelligence Layer

The Policy Intelligence Layer (PIL) transforms ATF from a transaction firewall into an intelligence system, turning every execution into signal, and every signal into better decisions.

A new primitive: systems that learn from execution without sacrificing determinism or control.

Execution History

Every policy decision is recorded with full context. Receipts become queryable signal for operators.

Actionable Intelligence

Aggregated execution data surfaces patterns, enabling operator-gated policy refinements grounded in real behavior.

Controlled Improvement

Operators review and approve every policy change. The system suggests, humans decide. Deterministic and auditable at every step.

Move transaction control out of the model loop.

ATF enforces policy, applies execution guardrails, and verifies outcomes outside the bot's token budget. That means less wasted compute on repetitive control logic, fewer invalid transaction loops, and more model capacity for higher-value intelligence.

Most systems execute transactions. TruCore systems learn from them.

Ecosystem

Integrated with the Solana ecosystem

ATF connects to the venues where autonomous agents operate, enforcing policy before every transaction reaches the chain.

AgentATFVenue

DEX

Jupiter
Orca
Raydium

Lending

Solend
Marginfi
Kaminogated

Perps

Drift v2gated
Mango v4gated
Hyperliquidgated

ATF enforces execution policies across decentralized exchanges, lending markets, and perpetual venues where autonomous agents operate.

ActiveFeature-gated

Production Readiness

Deterministic policy enforcement infrastructure for autonomous agents operating across Solana venues.

Scope

ATF V1 Scope

V1 is intentionally focused. Production-grade enforcement across a well-defined surface area, with real adapters for every supported venue and chain. Expansion happens only after each layer is proven.

Chains

  • Solana (primary)
  • Hyperliquid feature-gated
  • Base coming soon

Enforced Controls

  • Slippage bounds
  • Protocol allowlist
  • Max exposure caps
  • Transaction TTL
  • Nonce-based replay protection

Platform Surface

ATF is enforcement infrastructure, not just a CLI. Start with the golden path, then unlock advanced capabilities.

  • Golden path: trade → setup → doctor → verify
  • Dual-surface output: human-readable + bot-ready JSON
  • Public API with deterministic simulation
  • 13 native agent tools across 6 contract families
  • 8 production-ready example projects
  • 6 deployable services

Resources & Documentation

Explore

Everything you need to evaluate and integrate ATF.

Get Started

Try → Protect → Verify → Upgrade

Start free. Get receipts for every decision. Upgrade when your bot needs higher caps or real execution.

Start Your First Protected TradeGetting StartedPricing

Why Now

Autonomous finance is entering a phase where execution is real, adversaries are active, and risk surfaces compound quickly. The window to add hard enforcement, and intelligence that learns from it, is now.

Agents are executing

Agent-driven finance has moved from experiments to production workflows. Capital is now being deployed by autonomous systems in live environments.

MEV is adversarial by default

Execution happens in an adversarial arena where value extraction is automated. Any unbounded behavior is quickly priced and exploited.

Trust doesn’t scale, enforcement does

Human trust checks cannot keep pace with machine-speed decisions. Deterministic enforcement is how systems stay reliable as volume rises.

Execution must become intelligence

Protecting transactions is necessary but insufficient. Systems that learn from execution history, under operator control, make better decisions over time without sacrificing determinism.

Deterministic Enforcement Proof

The same input consistently produces the same policy decision and receipt hash.

Request JSON

{
  "action": "swap",
  "token_in": "SOL",
  "token_out": "USDC",
  "amount": 10,
  "max_slippage_bps": 100,
  "ttl_seconds": 60
}

Result JSON

{
  "status": "allowed",
  "reason": "Request satisfies demo policy limits.",
  "invariant_checks": [
    "amount <= 1000: pass",
    "max_slippage_bps <= 300: pass",
    "ttl_seconds <= 300: pass"
  ],
  "receipt_hash": "9d9e34f2df6dd5ecf0988cb3af0ea4ab60431b64d7d5e3b35d0972ce4e4c986f"
}
  • Policy evaluated before execution.
  • Invariants checked deterministically.
  • Receipt hash generated for tamper evidence.
  • Receipts are shareable and verifiable via CLI or web.
  • Output includes both human share text and bot-friendly structured data.
Run this example in the SimulatorProtect your first bot trade →

Roadmap

A phased approach. Each stage builds on proven enforcement before expanding scope.

  1. Phase 1

    V1 Guardrails (Solana core)

    Policy engine, permit gateway, execution validator, and receipt ledger for Solana. Jupiter, Orca, Raydium (swaps), Solend, Marginfi, Kamino (lending), and feature-gated perps integrations. Comprehensive CLI, API, agent tooling, example projects, and deployable services.

  2. Phase 2

    On-chain attestation registry

    Publish policy evaluations and execution receipts to an on-chain registry for transparent, verifiable audit. Solana programs deployed to devnet.

  3. Phase 3

    Vault and invariant enforcement program

    On-chain program enforcing portfolio-level hard invariants with vault-scoped custody and automatic halt logic.

  4. Phase 4

    Multi-chain expansion

    Hyperliquid enforcement is feature-gated today. Base support is coming soon. Additional chains and protocol integrations follow as each layer is proven.

View full roadmap →

Join the Waitlist

Get early-access updates, release notes, and security advisories.

For teams already building

Design Partner Program

Working with a limited cohort of early teams integrating ATF into production trading bots on Solana. This is not a waitlist - it is hands-on integration support.

Includes:

  • • Dedicated partner API key tier
  • • Integration guidance and policy design review
  • • Direct access to engineering
Apply as Design Partner

Deterministic policy evaluation

Cryptographic receipt hashing

Public demo policy transparency

Structured release discipline