How is Traverse different from function calling?

Function calling — as implemented by OpenAI, Anthropic, and others — gives an AI agent a JSON schema describing a function and lets it call that function. Traverse adds three things that raw function calling does not provide: runtime contract enforcement, WASM sandbox isolation, and a trace artifact on every execution.

Schema description vs. runtime enforcement

With standard function calling, the JSON schema in the tool definition is advisory. It helps the agent construct a valid call, but nothing stops the agent from sending invalid inputs if the LLM decides to. The receiving function sees whatever the agent sent. With Traverse, the contract is enforced at runtime. Invalid inputs are rejected before execution — the WASM binary never runs on bad data.

Arbitrary functions vs. sandboxed capabilities

Function calling connects an agent to any callable code: a Python function, a Node.js handler, a Lambda. That code can do anything — read files, make network calls, modify state. Traverse capabilities run in a WASM sandbox. They have no access to host resources unless explicitly granted. For sensitive business logic, this isolation matters.

No audit trail vs. trace artifacts

Function calling gives you whatever logging you build yourself. Traverse produces a trace artifact on every call as a side effect of the execution model. The artifact records the inputs, the precondition results, the WASM execution, the postcondition results, and the final output. You get an audit trail without building one.

When to use each

• Function calling: fast integration, arbitrary code, no portability requirement
• Traverse: business logic that needs enforcement, portability across runtimes, and auditability

Traverse is not a replacement for function calling in general. It is the right choice when the function being called is business-critical and you need the contract enforced rather than suggested.