AI Agent Readiness Audit for MCP & A2A

Audit API and agent readiness before you publish

Agent Readiness is a deterministic audit for developers and teams preparing APIs, repositories, MCP servers, A2A agents, or Apify Actors for machine discovery. It inspects a caller-supplied snapshot and returns a structured readiness report with evidence for every failed check.

Use it when you want a fast answer to questions such as: Is this OpenAPI definition usable by agents? Is the MCP metadata complete? Does the A2A Agent Card expose a clear skill? Is an Apify Actor packaged with the metadata an agent or marketplace expects?

The Actor does not execute repository code and does not use an LLM. The same input produces the same result for the same version of the audit rules.

Main use cases include:

• pre-release checks for API and AI agent infrastructure;
• MCP server readiness audits before registry submission;
• A2A Agent Card and skill metadata checks;
• OpenAPI agent compatibility checks;
• Apify Actor packaging checks;
• CI and release-gate evidence for teams publishing machine-consumable tools.

What it checks

For OpenAPI, Agent Readiness checks for basic documentation and licensing, an OpenAPI 3.x document, discoverable HTTP operations, stable operationId values, useful operation summaries, and declared responses.

For MCP, it checks for discoverable server metadata, a stable identity, a meaningful description, and declared tool metadata. For A2A, it checks for a well-known Agent Card, identity metadata, and declared skills. For Apify, it checks Actor metadata, an input schema, and explicit pricing metadata.

Every failed criterion is returned as a machine-readable finding with a code, severity, evidence path, explanation, and remediation. This makes the readiness report suitable for both humans and automated release workflows.

Input

Provide a files object that maps relative repository paths to UTF-8 text contents, plus one or more targets.

{
  "files": {
    "README.md": "# Example API\nUsage documentation",
    "LICENSE": "MIT License",
    "openapi.yaml": "openapi: 3.1.0\ninfo: {title: Example, version: 1.0.0}\npaths: {}"
  },
  "targets": ["openapi"]
}

Supported targets are openapi, mcp, a2a, and apify. You can request several targets in one audit. The optional repository_url is reference metadata only in the current release. The Actor does not clone that repository or fetch private source-control content.

Output

Each run writes one complete readiness report to the default Apify dataset. A report contains:

• status: READY, PARTIAL, or BLOCKED;
• score: deterministic readiness score from 0 to 100;
• findings: evidence-backed issues and recommended fixes;
• checks_run: number of deterministic checks evaluated.

Example:

{
  "status": "BLOCKED",
  "score": 75,
  "findings": [
    {
      "code": "openapi.operations_missing",
      "severity": "error",
      "message": "No HTTP operations were found",
      "evidence": ["openapi.yaml"],
      "remediation": "Define at least one path operation."
    }
  ],
  "checks_run": 5
}

Because the output is structured, another agent can consume the readiness report directly and decide whether to continue a deployment, request changes, or route the repository to a human reviewer.

Pricing

Agent Readiness uses Apify pay-per-event pricing. The initial beta contract charges one readiness-report event only when a complete readiness report is written to the default dataset. The introductory event price is USD 0.01 per report.

The price is intentionally simple so developers and agents can test the capability with low friction. Current pricing is always shown by Apify before execution and may be adjusted in future versions as the audit expands.

Why use a deterministic readiness report

AI infrastructure often fails at the boundary between working code and discoverable, well-described capabilities. A service may run correctly while lacking a stable operation ID, Agent Card, MCP tool description, Actor input schema, or other metadata that allows an external agent to understand and call it reliably.

Agent Readiness treats those interfaces as release requirements. It does not attempt to judge whether your product idea is good. It checks whether the supplied machine-facing artifacts satisfy explicit rules and shows the evidence behind the result.

This makes it useful as an independent readiness gate before publishing to Apify, exposing an MCP server, announcing an A2A agent, or shipping an OpenAPI-based integration.

Limitations

The current release evaluates caller-supplied text snapshots only. It does not execute code, clone repositories, authenticate to private source control, test live endpoint uptime, perform penetration testing, verify marketplace acceptance, or guarantee protocol certification.

A READY result means the supplied snapshot passes the deterministic checks implemented by this Actor version. It is not a security audit, legal review, production availability guarantee, or endorsement by Apify, the MCP project, the A2A project, or any other platform.

Do not include passwords, API keys, private keys, tokens, personal data, or other secrets in the files input. Submit only the artifacts needed for the readiness audit.

Publisher

Agent Readiness is published by suezcanal.xyz as part of its tools program for evidence-driven, machine-consumable decision infrastructure. Public contracts and discovery metadata are maintained separately from the private implementation so integrations can evolve without exposing commercial source code.