Govern AI Agents
Across 200+ Chains

Data Exposure

AI agents handling wallet addresses, private keys, and user PII without proper controls.

Unauthorized Actions

Trading bots exceeding limits, executing on wrong chains, or interacting with malicious contracts.

Compliance Failures

No audit trail, no human oversight, no way to prove governance to regulators.

Ethereum, Arbitrum, Optimism, Base, Polygon, BSC, Avalanche, zkSync

Hardhat Plugin + JS SDK

Solana, Eclipse

Rust SDK + Anchor

Cosmos Hub, Osmosis, Injective, Sei, Neutron + 50 IBC chains

Go SDK + CosmWasm

Aptos, Sui

Move SDK

Polkadot, Kusama + 100 parachains

Substrate Pallet

StarkNet, TON, Cardano

Native SDKs

AI Trading Bots

Problem: Uncontrolled AI agents can execute unauthorized trades, exceed limits, or interact with malicious contracts.

Solution: Tork validates every trade against policies: slippage limits, volume caps, token allowlists, and human approval thresholds.

DAO AI Assistants

Problem: AI-generated proposals may leak member PII, contain harmful content, or violate governance rules.

Solution: Tork scans proposals for PII, validates sentiment, and helps meet DAO constitution requirements.

NFT Generation

Problem: AI-generated NFTs may contain copyrighted content, PII in metadata, or non-compliant attributes.

Solution: Tork validates metadata, scans descriptions, and helps verify royalty settings against platform rules.

Smart Contract CI/CD

Problem: AI-suggested code may contain hardcoded secrets, exposed private keys, or wallet addresses.

Solution: Tork integrates with Hardhat/Foundry to scan every commit for secrets, PII, and security issues.

On-Chain AI Oracles

Problem: AI oracles can provide manipulated data, low-confidence predictions, or unverified sources.

Solution: Tork validates data sources, confidence scores, and maintains audit trails before on-chain submission.

Web3 dApps

Problem: AI-powered dApps may expose user data, make unauthorized calls, or violate compliance requirements.

Solution: Tork provides a governance layer for all AI interactions within your dApp.

Trust

Smart contract audit score

Oversight

Multi-sig/HITL requirements

Reliability

Uptime, gas efficiency

Knowledge

On-chain data accuracy

Integrity

No manipulation, verifiable

Neutrality

Fair MEV, no front-running

Governance

DAO compliance, voting rules

// hardhat.config.js
const { torkGovernance } = require('@tork/hardhat-plugin');

module.exports = {
  solidity: "0.8.19",
  plugins: [torkGovernance],
  tork: {
    apiKey: process.env.TORK_API_KEY,
    policies: ['no-pii', 'no-secrets', 'audit-trail'],
    failOnViolation: true
  }
};

// Anchor/Solana Integration
use tork_sdk::TorkGovernance;

#[program]
pub mod my_program {
    pub fn execute_with_governance(
        ctx: Context<Execute>,
        data: Vec<u8>
    ) -> Result<()> {
        // Tork validates before execution
        let governance = TorkGovernance::new()?;
        governance.validate(&data, Policy::Strict)?;

        // Proceed with on-chain logic
        Ok(())
    }
}

// CosmWasm Integration
use tork_cosmos::governance;

pub fn execute(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    msg: ExecuteMsg
) -> Result<Response> {
    // Validate AI-generated content
    governance::validate(&msg, deps.api)?;

    // Execute contract logic
    Ok(Response::new())
}

// Sui Move Integration
module tork::governance {
    use tork::validator;

    public fun validate_ai_output(
        content: vector<u8>
    ): bool {
        validator::check_pii(content) &&
        validator::check_policy(content) &&
        validator::check_compliance(content)
    }
}