Tork Phase 5: Complete AI Governance Platform Now Live
Introducing Memory Integrity, HITL Enforcement, Supply Chain Visibility, Cost Controls, and a complete Admin Console for production-ready AI governance.
Tork Phase 5 Dashboard
Complete AI Governance Platform
Correction — 3 August 2026
This post is from January 2026. Its code samples paired the on-device install line with the cloud family's entry class, so they did not run as printed — tork-governance exports Tork and has never exported TorkClient. The snippets below are corrected in place.
tork-governance makes the governance decision on your machine. PII detection, redaction and the returned verdict are computed on-device. With no API key it makes zero network calls: prompts, completions and detected PII values never leave the machine, and nothing appears in your dashboard.
Supply an API key and the SDK additionally reports a metadata-only attestation of each decision — the action taken, PII type labels and counts, a risk classification, policy labels and a salted fingerprint. It never sends input text, output text or PII values. The decision itself is still made on-device and is never delayed or changed by reporting. Those attestations appear in your dashboard and are included in the daily on-chain anchor — each one recorded as a client attestation (capture_mode=edge, attested_by=client), a claim Tork recorded but did not execute and cannot independently verify. Requires tork-governance 0.24.0+ (PyPI) or 0.11.0+ (npm).
A decision reported by an on-device SDK is recorded as a client attestation (capture_mode=edge, attested_by=client): a claim Tork recorded but did not execute and cannot independently verify. A decision made by @torknetwork/sdk is recorded as capture_mode=cloud, attested_by=tork — Tork made that call itself. Both are equally immutable once anchored; they differ in what is immutable. A client attestation freezes your claim. A server-governed receipt freezes Tork's own decision.
Memory Integrity, HITL Enforcement, Supply Chain Visibility, Cost Controls and the Admin Console described below are cloud-path features, reached through the Tork API and @torknetwork/sdk. Local governance is free and unlimited — decisions made on your own machine are never metered. Evidence is what is metered: attestations, receipts and anchoring.
Why AI Governance Matters
As AI agents become more autonomous, the need for robust governance has never been greater. Organizations are deploying agents that can access sensitive data, make financial decisions, and interact with production systems. Without proper guardrails, the risks are significant: data breaches, runaway costs, compliance violations, and loss of trust.
Tork is the AI governance platform that solves these challenges. We provide comprehensive tools for PII protection, policy enforcement, audit logging, and now with Phase 5, we've added memory integrity, human oversight, supply chain security, and cost controls.
What's New in Phase 5
Memory Integrity & Trust Scoring
Cryptographic verification of agent memory with drift detection and trust scoring.
HITL Enforcement
Human-in-the-loop approval workflows with slicing attack detection and velocity limits.
Supply Chain Visibility
Track dependencies and vulnerabilities across models, packages, and tools.
Cost Controls
Budget governance with spend tracking, alerts, and hard limits per agent or team.
MCP Tool Auditing
48 governance tools for Claude, Cursor, and any MCP-compatible agent.
Memory Integrity: Trust Your Agent's Memory
Agent memory can be modified, corrupted, or poisoned over time. Memory Integrity provides cryptographic snapshots that detect unauthorized changes and calculate trust scores based on verification history.
# Memory Integrity is a CLOUD-path feature, served by the
# Tork API and the cloud SDK (@torknetwork/sdk, entry class
# TorkClient). It is NOT part of the on-device
# tork-governance package, which exports only `Tork`.
client = TorkClient(api_key="your_key")
memory = MemoryIntegrity(client)
# Take a snapshot of agent memory
snapshot = memory.snapshot(
agent_id="agent-1",
memory_data=agent.get_memory(),
memory_type="conversation"
)
# Later, verify memory hasn't been tampered with
result = memory.verify(agent_id="agent-1")
print(f"Trust Score: {result['trustScore']}/100")
print(f"Modifications: {result['modificationCount']}")HITL Enforcement: Humans in the Loop
Some actions are too risky for full automation. HITL Enforcement lets you require human approval for high-stakes decisions, with slicing attack detection to prevent agents from breaking up large operations to avoid oversight.
Slicing Attack Detection
Detect when agents split operations to avoid thresholds
Velocity Limits
Limit how many approvals can be requested per time period
Cool-down Periods
Enforce waiting periods between sensitive operations
Context Preservation
Reviewers see full context for informed decisions
Admin Console: No-Code Governance
Not everyone wants to write code to manage AI governance. The Admin Console provides a complete web interface for managing agents, policies, budgets, approvals, and alerts.
Dashboard
Real-time TORKING-X scores and system health
Agents
Register, monitor, and manage AI agents
Policies
Visual rule builder for governance policies
Budgets
Create and track spending limits
Approvals
HITL approval queue with context
Alerts
Monitor and respond to governance events
TORKING-X: The Industry Standard
TORKING-X is our 9-metric scoring system for AI governance health. Each metric is weighted based on its importance, giving you a single score (0-100) that represents your overall governance posture.
Tamper-Evidence
10%
Privacy Protection
15%
Ephemeral Identity
10%
Quality Guardrails
15%
Circuit Breakers
15%
Supply Chain
10%
Tool Safety
10%
Memory Integrity
10%
HITL Enforcement
5%
Combined into a single governance score from 0-100
Getting Started
Start using Tork in minutes. Pick the family that matches where you want the decision made:
# On-device family — decides locally, entry class `Tork`
pip install tork-governance # Python
npm install tork-governance # JavaScript/TypeScript
# Cloud family — Tork decides server-side, entry class `TorkClient`
npm install @torknetwork/sdkfrom tork_governance import Tork
# No api_key = fully local, zero network calls
tork = Tork()
# govern() is synchronous and decides on-device
result = tork.govern("User message here")
if result.action == "deny":
# Handle policy violation
log_violation(result.pii.types)
else:
# result.output is the PII-redacted text
process_with_llm(result.output)What's Next
Phase 5 completes our core governance platform, but we're not stopping here. On our roadmap:
- Enterprise SSO - SAML, OIDC, and custom identity providers
- Advanced Analytics - ML-powered anomaly detection and insights
- On-Premise Deployment - Self-hosted option for air-gapped environments
- More Integrations - Vercel AI SDK, Haystack, DSPy, and more
Try Tork Today
Get started with Tork for free. No credit card required. See how easy it is to add governance to your AI agents.