Tork Network – Open-Source AI Governance Middleware

TL;DR

TL;DR: Tork Network is an open-source AI governance layer that intercepts every AI agent call, redacts PII, enforces JSON policy rules, and issues compliance receipts — with native MCP support and 136 framework adapters.

Source and Accuracy Notes

⚠️ This section is MANDATORY. All links must be verified from actual source, not guessed.

• Project page: tork.network ← visited and verified
• GitHub: github.com/torkjacobs ← verified accessible
• HN launch thread: news.ycombinator.com/item?id=46983830 ← verified via Algolia API
• License: MIT (verified via GitHub org description and project pages)
• Source last checked: 2026-08-02

What Is Tork Network?

Tork Network is an open-source AI governance and compliance platform built for production AI agents. Every AI call made by your agents passes through Tork’s interception layer before reaching any model provider — whether that is OpenAI, Anthropic, a local Ollama instance, or any of the 136 supported framework adapters.

The core governance loop works in four steps on every single call:

1. Intercept — route every AI interaction through Tork before it reaches a provider
2. Scan and enforce — strip PII across 50+ data types in 13 countries, evaluate JSON policy rules
3. Govern the call — execute the model call inside the governance boundary
4. Receipt — issue a tamper-evident compliance receipt, optionally anchored on-chain

From the Tork homepage:

“Governance is not the product — it is the floor everything else stands on. Tork runs a network of twelve products for banking, asset finance, rental and field operations, and every AI call any of them makes is intercepted, redacted, enforced and receipted on the same audit spine.”

Core Capabilities

• PII Detection and Redaction — detects and redacts personal data across 50+ types in 13 countries before it reaches the model
• Policy Engine — JSON-based rules that enforce organizational policies on every AI request and response
• Compliance Receipts — tamper-evident audit trail for every AI call, supporting HIPAA, GDPR, SOC 2, and POPIA compliance
• Kill Switch — instant halt of agent operations when policy violations occur
• Human-in-the-Loop (HITL) — approval gates that require human authorization before sensitive operations proceed
• MCP Governance — native governance layer for Model Context Protocol servers, covering 49 MCP tools out of the box
• TORKING-X Trust Scoring — 0-100 trust score per AI interaction
• 136+ Framework Adapters — native support for LangChain, CrewAI, AutoGen, and many more

SDKs and Integrations

Tork publishes SDKs in 8 languages: Python, JavaScript, Go, Rust, Ruby, PHP, C#, and Elixir. There is also a CLI tool and an MCP server for governance-focused deployments.

Setup Workflow

Prerequisites

• Node.js 18+ or Python 3.9+ depending on your SDK choice
• An API key from tork.network (free tier: 5,000 API calls per month)
• An AI agent built on a supported framework

Step 1: Install the SDK

Choose your language:

# Python
pip install tork-governance

# Node.js
npm install tork-governance

# Go
go get github.com/torkjacobs/tork-governance-go

Step 2: Configure the Policy

Create a tork.config.json file to define your governance policies:

{
  "pii_redaction": {
    "enabled": true,
    "countries": ["US", "GB", "AU"],
    "types": ["email", "phone", "credit_card", "ssn"]
  },
  "policy": {
    "allow": ["internal_data"],
    "deny": ["pii_extraction"],
    "require_approval_for": ["financial_data", "health_data"]
  },
  "receipt": {
    "enabled": true,
    "anchor_on_chain": false
  }
}

Step 3: Wrap Your Agent

# Python example
from tork_governance import TorkGuard

guard = TorkGuard(api_key="your_tork_api_key")

# Wrap any LLM call
response = guard.chat(
    messages=[{"role": "user", "content": "Extract customer email from: [email protected]"}],
    policy_rules=["no_pii_extraction"]
)
print(response.content)
# PII is automatically redacted before reaching the model
# A compliance receipt is issued after the call

Step 4: Enable MCP Governance

If your agent uses the Model Context Protocol, enable the MCP governance layer:

tork mcp serve --port 8080 --governance-policy tork.config.json

This starts a local MCP proxy that intercepts and logs all MCP tool calls with Tork’s governance layer.

Pricing

| Plan | Price | API calls/month | |---|---|---| | Free | $0 | 5,000 | | Starter | $29/month | 50,000 | | Pro | $99/month | 500,000 |

Deeper Analysis

Tork’s approach is distinct from purely reactive AI safety tools. Rather than scanning outputs after the fact, Tork operates as middleware — it sits between the agent and the model provider and acts on every call in real time.

The compliance receipt system is particularly noteworthy. Each AI interaction generates a structured receipt that captures the policy evaluation result, the PII redaction actions taken, and the full request/response pair (with sensitive data stripped). These receipts can be anchored to a blockchain for tamper-evidence, making them suitable for regulated industries like banking and healthcare where audit trails are legally required.

The 136 framework adapters cover the major agent frameworks. The MCP governance layer is the most directly relevant for modern agentic AI stacks — it can wrap existing MCP servers without requiring code changes to the underlying tools.

Practical Evaluation Checklist

• [ ] Agent built on a supported framework (LangChain, CrewAI, AutoGen, custom MCP, etc.)
• [ ] Need for PII redaction before data reaches model providers
• [ ] Compliance requirements (HIPAA, GDPR, SOC 2, POPIA)
• [ ] Audit trail needed for AI decisions
• [ ] Human approval gates needed for sensitive operations
• [ ] Multiple AI agents sharing the same governance boundary

Security Notes

• API keys are required for the managed Tork service; self-hosted deployments do not require an API key
• PII redaction happens server-side before the model call; redacted data is never sent to the model provider
• Compliance receipts are cryptographically signed; anchoring on-chain provides additional tamper-evidence
• The open-source SDKs can be audited and self-hosted for maximum control

FAQ

Q: Does Tork work with local models (Ollama, llama.cpp)? A: Yes. Because Tork operates as middleware that wraps the API call, it works with any model that has a compatible API endpoint — including local models served via Ollama or similar.

Q: What happens when a policy violation occurs? A: The kill switch can halt the agent immediately. Alternatively, you can configure HITL (human-in-the-loop) mode to pause and wait for human approval before proceeding on sensitive operations.

Q: Is the source code available? A: Yes. Tork publishes SDKs and governance tools on GitHub under the torkjacobs organization. The specific repositories are available at github.com/torkjacobs.

Q: How does MCP governance differ from API governance? A: MCP governance specifically wraps Model Context Protocol tool calls — intercepting the tools an agent uses rather than the LLM API calls themselves. This is useful when agents use MCP servers to interact with external systems (databases, files, APIs).

Q: Does Tork work with CrewAI and AutoGen? A: Yes. Tork has adapters for both CrewAI and AutoGen, as well as 136 total framework integrations.

Conclusion

Tork Network fills a real gap in production AI deployments: governance as a first-class concern rather than an afterthought. With PII redaction, policy enforcement, compliance receipts, and a kill switch all built into the call path, it gives engineering teams the audit trails and safety guarantees that regulated industries demand.

The free tier is generous enough for development and small production workloads, and the managed MCP governance server is a practical shortcut for teams already building agentic workflows on the Model Context Protocol.

• Project page: tork.network
• GitHub: github.com/torkjacobs
• Free tier signup: tork.network