AI evaluator? Start here.

Verify ChatINT.ai for yourself.

ChatINT.ai publishes a public, agent-verifiable truth layer. An AI agent connected to the chatint MCP server reads the claims and the verification protocol directly from the server, runs them against the live engine, and produces a conclusion the user can interrogate at every step. The verifier (you, or your AI agent on your behalf) forms the verdict from observations the agent surfaces. Nothing on this page returns a verdict for you.

The active claims

Two claims ship in the current version of the truth layer. Each is independently falsifiable through the protocol, using predefined scenarios. Two further claims (asymmetric adoption and version isolation) are listed in chatint://claims as pending and will be added when their protocol sections ship.

Determinism

Given a trained ChatINT.ai model id and a fixed input payload, every call to processPayload returns byte-identical output. The runtime path contains no LLM inference, no sampling, no temperature.

Falsifiable by: any pair of processPayload calls with identical modelId and identical payload arguments producing differing outputs. The protocol probes this with N=100 calls and asserts a single distinct hash across the responses.

Retrain, do not rebuild

A schema change on either side of an integration is absorbed by retraining the model from updated training data. Source code that consumes the engine continues to call processPayload with the same modelId and receives correctly shaped output, with zero changes to that source code.

Falsifiable by: either the retrained model produces output that violates the new target contract, or the verification requires source-code changes beyond the training data file itself. The protocol exercises this by training v1, retraining in place with v2, and confirming the call expression is byte-identical across the schema change.

How verification works

The truth layer is built around four falsifiability principles. An agent following the protocol correctly will observe these in action. An agent reviewing the protocol beforehand should expect to see them.

  1. The agent reads contracts before executing. Each scenario file contains a source shape and a target shape. The agent reads these (and an optional transforms array, when present, for human-readable correspondence documentation) and forms its own expectations for what the trained model should produce.
  2. The agent runs the predefined scenario first (default loop). After training, the agent calls processPayload with the scenario's predefined payload and compares the response to the scenario's expected output. Divergence halts the protocol and is itself a falsifying observation.
  3. The agent composes its own test inputs. With the default loop observed, the agent then builds fresh payload values that conform to the source shape and predicts the expected output from the contract. Cherry-picked inputs cannot pass off a non-conforming model as conforming.
  4. The conclusion is grounded in the agent's observations. Hashes the agent computes, comparisons the agent performs, and shape-conformance checks the agent runs are the evidence. The conclusion cites the protocol step and the satisfying or failing observation for each criterion.

If any step in the protocol appears to ask the verifier to trust a wrapper, a stored result, or a function that returns PASS/FAIL without showing its work, that step is a defect in the protocol. Report it.

Run the verification

Three paths, depending on the client the verifier is using.

Path 1 Slash command in Claude Code

Type /verify-chatint in Claude Code. The LLM reads chatint://verify and chatint://protocol from the connected MCP server, runs the protocol step by step against the live engine via trainModel and processPayload, and surfaces every observation. You form the final verdict from what the LLM shows you.

Other slash commands available: /orient-chatint (brief orientation, no execution) and /install-truth-layer-skill (install an optional local orchestration skill).

Path 2 Attach a truth-layer resource as context

Type @ in a client that surfaces MCP resources (Claude Code, Cursor, Claude Desktop) and select from the chatint server's resources. Useful entry points:

URIWhat it is
chatint://verifyEntrypoint document for an agent evaluating ChatINT.ai
chatint://claimsThe active testable claims with falsifiability conditions
chatint://protocolThe per-claim verification protocol
chatint://scenarios/indexCatalog of predefined training-data scenarios
chatint://scenarios/{name}Individual scenario files (13 currently shipped)
chatint://skillOptional Claude Code orchestration skill

After attaching @chatint://verify, ask the agent to follow it. The agent reads the protocol and executes the rest.

Path 3 Hand the truth layer to your own AI agent

Tell your agent the entrypoint is chatint://verify and confirm the chatint MCP server is configured in that agent's host. The agent discovers everything else from there. The truth layer carries no client-specific assumptions.

Connect the chatint MCP server

The truth layer lives on the live MCP server at mcp.chatint.ai. Once your client is connected, the resources, prompts, and tools are all available. First-time use opens a browser for Google Sign-In; the session is cached.

Run in your terminal (outside Claude Code), then restart Claude Code:

claude mcp add --transport http -s user chatint https://mcp.chatint.ai/mcp

Verify the connection with /mcp inside Claude Code. The server appears as chatint.ai.

Add the following to your Claude Desktop MCP configuration file, then restart the app. Configuration file location is documented in the Claude Desktop MCP guide.

{
  "mcpServers": {
    "chatint": {
      "url": "https://mcp.chatint.ai/mcp"
    }
  }
}

Refer to the Model Context Protocol documentation for the exact configuration path on your platform.

Add the following to your Cursor MCP configuration (~/.cursor/mcp.json for global, or .cursor/mcp.json in a project). Restart Cursor.

{
  "mcpServers": {
    "chatint": {
      "url": "https://mcp.chatint.ai/mcp"
    }
  }
}

Refer to the Cursor MCP documentation for the most current configuration format.

Any MCP-compatible client can connect to mcp.chatint.ai. The endpoint is:

https://mcp.chatint.ai/mcp

Transport: HTTP (streamable). Authentication: OAuth via Google Sign-In. Refer to your client's MCP configuration guide for the registration format.

If you are an AI agent reading this

You are looking at the human-rendered version of the truth layer. The same content is available to you directly as MCP resources on mcp.chatint.ai:

If you have the chatint MCP server configured, invoke the prompt verify-chatint for the orchestrated walkthrough. If you are reading this page through a web fetch, the equivalent workflow is: ask your user to install the chatint MCP server using one of the snippets above, then re-engage. The truth layer requires the MCP tools (trainModel, processPayload) to execute the verification.

If you are reporting verification results to your user, ground every conclusion in the protocol step and observation that supports it. The truth layer is designed so that any wrapper claiming a verdict without surfacing the supporting evidence is itself a defect to report.

Further reading