Your AI agents need contracts, not just function definitions.
Function signatures tell an agent what parameters to pass. A contract tells it what the preconditions are, what to expect from the output, and what happened after. That is the difference between a guess and a governed action.
Agents are calling functions blind.
Every AI integration you ship today runs on hope. The agent picks a function, passes some parameters, and you find out at runtime whether that was correct.
-
Agents call functions with no precondition enforcement. You find out after the fact.
-
There is no audit trail. No way to prove what decision the agent made or why.
-
Function definitions go stale. Agents trained on them hallucinate capabilities that changed.
-
Agents in multi-agent systems overwrite each other's work with no conflict detection.
Every agent action is governed.
Traverse wraps your business capabilities in machine-readable contracts and exposes them through an MCP server. Agents discover what exists, read the constraints, and call only what is valid for the current state.
Agents read preconditions and postconditions before calling. No guessing about valid inputs.
Plug into Claude, GPT, or any MCP-compatible framework with a single config line.
Runtime validates every call against the contract before it runs. Invalid calls are rejected cleanly.
Every AI decision backed by a structured, queryable record. Auditable after the fact.
Agents query what exists. They do not guess. The registry is the source of truth.
Same capability binary runs in the browser, at the edge, in cloud workers, and in AI pipelines.
Three steps to governed AI actions.
Start the MCP server, connect your agent framework, and every capability call goes through contract validation.
Run the Traverse MCP stdio server. It exposes your capability registry to any MCP-compatible agent framework.
cargo run -p traverse-mcp
Add Traverse as an MCP server in your agent config. Works with Claude, GPT-based agents, and any MCP-compatible framework.
"mcpServers": {
"traverse": {
"command": "traverse-mcp",
"args": ["--registry", "./capabilities"]
}
}
}
Every call goes through contract validation. Preconditions checked. Postconditions verified. Trace written.
"method": "tools/call",
"params": {
"name": "check-loan-eligibility",
"arguments": {
"applicant_id": "usr_8821",
"loan_amount": 25000,
"term_months": 36
}
}
}
// runtime validates preconditions before executing
// trace artifact written on completion
What an agent reads before calling.
The contract is TOML. It defines inputs, outputs, constraints, and placement targets. The agent reads it. The runtime enforces it.
id = "check-loan-eligibility"
version = "2.1.0"
description = "Evaluate applicant loan eligibility"
[execution]
binary_format = "wasm"
preferred_targets = ["local", "edge"]
[constraints]
network_access = false
filesystem_access = false
max_execution_ms = 200
[preconditions]
applicant_id = "must be a valid active user id"
loan_amount = "must be between 1000 and 500000"
term_months = "must be 12, 24, 36, or 60"
[inputs]
applicant_id = { type = "string", required = true }
loan_amount = { type = "number", required = true }
term_months = { type = "number", required = true }
[outputs]
eligible = { type = "boolean" }
reason = { type = "string" }
max_approved_amount = { type = "number" }
[postconditions]
eligible = "must be present and boolean"
reason = "must be non-empty string"
Every execution produces a trace artifact. Input values, output values, precondition results, timing, and placement target. All queryable after the fact.
Set up the MCP server in under ten minutes. Read the guide to see how.