Enact - Verified AI Tools Registry

TL;DR

TL;DR: Enact is a verified registry for AI agent tools—think npm for AI agents. Each tool carries cryptographic proofs that it only does what its metadata claims, letting you safely run third-party AI tools without trusting their code blindly.

Source and Accuracy Notes

• Product: enact.tools
• Launch HN: Show HN: Enact – A package manager for AI agent tools (YC W26, 6pts)

What Is Enact?

Most AI agent frameworks let you install “tools” from a registry—but the registry is just a list. Nobody checks whether the tool actually does what its documentation claims. A tool named send_email might silently read your contacts and forward them to a third party.

Enact solves this with cryptographic verification. When a tool is published to the Enact registry, it goes through a verification process that generates cryptographic artifacts proving the tool’s behavior matches its declared intent. Before running any tool, you can verify the proof. If it doesn’t check out, the tool doesn’t run.

The core use case: install and run AI agent tools with mathematical guarantees about their behavior, not just social trust.

Architecture

User App → Enact Registry → Tool Metadata + Cryptographic Proof
                          → Verified Tool Binary
                          → Execution Sandbox

The registry acts as the package manager. The cryptographic proof is generated at publish time and stored on-chain or in a verifiable log. At runtime, the agent’s executor verifies the proof before executing the tool.

Step 1: Install the Enact CLI

npm install -g enact-cli

Step 2: Browse the Registry

enact search "email"

This lists all verified tools matching the keyword, along with their verification status and documentation.

Step 3: Install and Verify a Tool

enact install send-email

The install command downloads the tool and its cryptographic proof, then verifies the proof against the tool’s actual behavior before completing installation.

Step 4: Run with Verification

enact run send-email --to "[email protected]" --body "Hello"

The runtime executor verifies the tool’s behavior at every call. If the tool deviates from its declared behavior, execution fails.

Deeper Analysis

Why Cryptographic Verification Matters

Traditional package managers (npm, PyPI, crates.io) verify that a package’s checksum matches what was published, but they don’t verify that the package’s behavior matches its documentation. For npm packages your AI agent executes, this is a critical gap—an agent calling file_operations.read_file(path) might silently escalate to file_operations.delete_all_files().

Enact closes this gap by verifying the tool’s actual behavior against its declared permissions. The verification generates a proof that can be checked without re-running the tool.

Tool Categories

The registry currently covers domains like:

• Communication: email, SMS, messaging
• File operations: read, write, delete with bounded scope
• Web access: HTTP GET/POST with allowed domains
• API integrations: Stripe, Slack, GitHub with OAuth scoping

Comparison with Related Tools

| Tool | Verification | Registry | Cryptographic Proof | |---|---|---|---| | Enact | ✓ Behavioral proofs | ✓ Native | ✓ On-chain | | ToolJet | ✗ No proof system | ✓ Native | ✗ | | n8n | ✗ No proof system | ✓ Community nodes | ✗ | | MCP | ✗ No proof system | ✓ Official registry | ✗ |

Enact’s differentiation is the cryptographic proof layer. For production AI agent deployments, especially in regulated industries, this matters.

Practical Evaluation Checklist

• [ ] Can browse the Enact registry without installing CLI
• [ ] Does CLI install work on macOS, Linux?
• [ ] Does verification pass for a known-good tool?
• [ ] Does verification fail for a tampered tool?
• [ ] Is the tool scope (filesystem, network) clearly declared?

Security Notes

• Enact does not run tools in a sandbox by default—that’s the host environment’s responsibility
• Cryptographic proofs verify behavior at publish time, not at runtime
• Some tools may require platform-specific verification in containers
• The registry is only as trustworthy as its verification process

FAQ

Q: Is Enact ready for production use?

A: Enact is actively developed. The verification process works for well-scoped tools, but the registry is still growing. For production, check whether the specific tool you need has been verified.

Q: Can I publish my own tools to Enact?

A: Yes—submit your tool with its behavioral specification and the verification pipeline will generate the proof. The process is documented on the Enact site.

Q: How is Enact different from MCP?

A: MCP defines a protocol for connecting AI agents to tools. Enact adds a verification layer on top—MCP tells the agent how to call the tool, Enact verifies that the tool does what it claims.

Q: Does Enact work with LangChain, LlamaIndex, and other frameworks?

A: Enact is framework-agnostic at the execution layer. The CLI can be integrated into any Python or JavaScript project as a library. Check the SDK docs for framework-specific integration.

Conclusion

Enact is a pragmatic solution to a real problem: third-party AI agent tools have essentially no trust verification. The npm world solved this with checksums and lockfiles, but for AI agents, the problem is deeper because the “package” is executable code that can do arbitrary things at runtime.

If you’re deploying AI agents that call third-party tools, Enact’s registry-plus-proof approach is worth evaluating. The 6 HN points reflect that it’s very new, but the problem it solves is genuine.