Difference Between Supported, Internal-Compatible, and Candidate Tool Tiers in Claude-Code-Harness

Supported tier requires full runtime smoke tests and public installation paths, internal-compatible tier verifies static artifacts like mirrors and setup scripts but lacks complete runtime proof, and candidate tier represents research-only adapters with documentation but no verified smoke tests.

The Chachamaru127/claude-code-harness repository maintains a rigorous classification system for AI coding assistants that determines their production readiness. Understanding the difference between supported, internal-compatible, and candidate tool tiers helps developers select appropriate integration paths and contributes to the project's capability matrix. Each tier corresponds to specific evidence requirements defined in spec.md and enforced through automated validation in tests/test-tool-capability-matrix.sh.

Supported Tier: Full Runtime Verification

According to spec.md at line 168, the supported tier represents the highest level of integration, requiring verified install paths, successful skill loading, at least one end-to-end workflow smoke test, and passing all release-gate checks. Tools in this category maintain stable public APIs and undergo version-controlled updates.

Claude Code itself occupies this tier, as documented at line 177 of spec.md. The classification indicates that the tool has demonstrated complete bootstrap functionality through automated smoke tests and maintains verified plugin marketplace paths.

Internal-Compatible Tier: Static Evidence Without Runtime Proof

The internal-compatible tier, defined at line 169 of spec.md, applies when the repository contains static compatibility artifacts—including mirrored repositories, setup documentation, package validation, or local tooling—but lacks comprehensive runtime smoke proof. This distinction allows internal development against these tools while withholding public guarantees of full parity.

Current examples include Codex CLI (lines 178-179) and OpenCode (lines 180-181), which maintain verified repository mirrors and setup scripts such as setup-codex.sh and setup-opencode.sh within docs/onboarding/install.md. While these tools function correctly in static analysis and local setup scenarios, the Harness has not yet observed a full runtime bootstrap smoke that would qualify them for supported status.

Candidate Tier: Research-Only Adapters

As specified in spec.md lines 170-172, the candidate tier identifies tools with viable adapter paths, prototype documentation, or exploratory code, but absolutely no executed smoke tests. These entries represent "research-only" hosts where runtime behavior remains under investigation.

Cursor, Codex app, GitHub Copilot CLI, and Antigravity CLI currently hold candidate status. The repository may contain adapter skeletons or preliminary documentation for these tools, but no end-to-end runtime verification exists, prohibiting any public claims of functionality.

Key Distinctions Between the Three Tiers

Runtime Smoke Proof

• Supported: Required and present; verified through end-to-end workflow tests
• Internal-Compatible: Missing; only static evidence and setup validation exists
• Candidate: Missing; research-only with no runtime verification

Public Communication Policy

• Supported: Permitted in README, release notes, and public documentation
• Internal-Compatible: Allowed only with explicit "internal-compatible" wording; no guarantees of public parity
• Candidate: Must never be advertised as supported; internal research mentions only

Typical Artifacts

• Supported: Full install scripts, verified plugin marketplace integration, automated CI/CD smoke tests
• Internal-Compatible: Mirror repositories, shell setup scripts, static package validation, companion wrappers
• Candidate: Documentation stubs, prototype adapters, exploratory test files

Promotion Pathway

• Supported: Stable classification; changes only via formal version bump
• Internal-Compatible: Can elevate to supported after runtime smoke proof completion
• Candidate: Can advance to internal-compatible upon maturation of static artifacts, then to supported following smoke verification

Verifying Tool Tiers in Source Code

To inspect the current tier classification for any tool, query the specification file directly:

# Check specific tool tier in spec.md

grep -n "Codex CLI" spec.md      # Shows lines 178-179: internal-compatible

grep -n "Cursor" spec.md          # Shows lines 181-182: candidate

grep -n "Claude Code" spec.md    # Shows line 177: supported

For programmatic validation against the capability matrix, implement tier-checking logic similar to the test suite:

// Tier validation logic from test-tool-capability-matrix.sh principles
const tiers = {
  "Claude Code": "supported",
  "Codex CLI": "internal-compatible",
  "OpenCode": "internal-compatible",
  "Cursor": "candidate",
};

function isPubliclySupported(tool) {
  return tiers[tool] === "supported";
}

function canPromoteToSupported(tool) {
  return tiers[tool] === "internal-compatible";
}

Authoritative Source Files

File	Purpose	Evidence Location
spec.md	Central tier definitions and requirements	Lines 168-172 define the three tiers; lines 177-182 list current tool classifications
docs/tool-capability-matrix.md	Human-readable compatibility table	Surfaces public-facing tier claims for all integrated tools
docs/onboarding/install.md	Internal-compatible setup guides	Contains setup-codex.sh and setup-opencode.sh documentation
tests/test-tool-capability-matrix.sh	Automated validation	Fails CI if documentation claims contradict spec.md definitions
README.md / README_ja.md	Public tier declarations	Must remain synchronized with spec.md classifications

Summary

• Supported tools require complete runtime smoke tests, verified installation paths, and passing release-gate checks, as defined in spec.md line 168.
• Internal-compatible tools maintain static artifacts like repository mirrors and setup scripts but lack runtime bootstrap proof, per spec.md line 169.
• Candidate tools exist as research artifacts with adapter skeletons but no smoke tests, specified in spec.md lines 170-172.
• Codex CLI and OpenCode are currently internal-compatible, while Claude Code is supported and Cursor remains candidate.
• The tests/test-tool-capability-matrix.sh script enforces that public documentation never exceeds the tier levels defined in spec.md.

Frequently Asked Questions

What distinguishes internal-compatible from candidate tier?

Internal-compatible tools have verified static artifacts such as mirrored repositories, setup documentation, and package validation scripts, whereas candidate tools possess only research documentation or adapter skeletons with no static validation whatsoever. According to spec.md, internal-compatible status requires tangible setup artifacts like setup-codex.sh, while candidate status applies when only exploratory documentation exists.

Can I use internal-compatible tools in production workflows?

You may use internal-compatible tools internally, but the claude-code-harness explicitly prohibits advertising them as fully supported in public documentation or release notes. These tools lack the runtime smoke proof required for supported status, meaning their bootstrap behavior may vary across environments despite having verified setup scripts.

How does a tool move from candidate to supported status?

A candidate tool first advances to internal-compatible by establishing static artifacts including repository mirrors and setup documentation, then progresses to supported after achieving a complete runtime bootstrap smoke test that passes all release-gate checks. Each promotion requires updates to spec.md and verification by tests/test-tool-capability-matrix.sh.

Where is the single source of truth for tier definitions?

The spec.md file at the repository root serves as the authoritative specification, with lines 168-172 containing the canonical definitions of supported, internal-compatible, and candidate tiers. The docs/tool-capability-matrix.md and README files derive their classifications from this source, and automated tests ensure consistency across all documentation.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}