How to Configure Multi-CLI Support for Claude Code, Codex, OpenCode, and Antigravity

Career-Ops provides AI-agnostic multi-CLI support by separating CLI entry points from core pipeline logic via tier-mapped configuration files, allowing seamless switching between Claude Code, Codex, OpenCode, and Antigravity without modifying repository code.

The santifer/career-ops repository implements a CLI-agnostic architecture that enables the same automation pipeline to run across multiple AI coding agents. By abstracting model selection through cost tiers and maintaining CLI-specific entry point wrappers in the repository root, you can configure multi-CLI support to leverage different agents interchangeably while preserving a single source of truth for your career operations logic.

Understanding the Multi-CLI Architecture

CLI Registry and Entry Points

The foundation of multi-CLI support resides in [docs/SUPPORTED_CLIS.md](https://github.com/santifer/career-ops/blob/main/docs/SUPPORTED_CLIS.md), which enumerates every supported CLI and maps each to a specific entry file in the repository root. These entry files—CLAUDE.md, CODEX.md, OPENCODE.md, and AGENTS.md—function as thin wrappers that forward prompts to the shared career-ops skill logic defined in AGENTS.md.

Each wrapper loads the core pipeline and injects CLI-specific environment variables (such as API keys) while maintaining version control alongside the project code. This design ensures that updating a wrapper requires editing only a single markdown file without touching the core logic in modes/.

Abstract Tier Mapping

Model selection operates through an abstraction layer defined in [modes/_shared.md](https://github.com/santifer/career-ops/blob/main/modes/_shared.md). This file maps each CLI to three cost tiers—economy, standard, and premium—using abstract tier names rather than concrete model identifiers.

The tier table enables the same configuration to work across any CLI:

• OpenCode: Maps economy to cheapest/fastest, standard to balanced, and premium to most capable
• Codex: Follows the same pattern with provider-specific model selections
• Antigravity: Uses adaptive extended thinking settings mapped to tiers

Because the runtime reads these tier mappings at execution time, the same source file works for any CLI, and you can update model selections by modifying a single row when providers change their offerings.

Configuring Your User Profile

All multi-CLI behavior is driven by config/profile.yml, which contains two critical keys:

language:
  output: en
spend_tier: standard   # Options: economy | standard | premium

When any CLI invokes Career-Ops, the runtime reads spend_tier and selects the appropriate model from the tier table for that specific CLI. This means executing the same command across Claude Code, Codex, OpenCode, or Antigravity produces output at the identical cost level without code changes.

To change your default spending behavior across all CLIs, modify the spend_tier value in this configuration file.

Running Career-Ops Across Different CLIs

Interactive Mode

Invoke the interactive mode for each CLI using its native command, then trigger the Career-Ops skill:

• Claude Code

  claude
  > /career-ops

• Codex

  codex
  > /career-ops

• OpenCode

  opencode
  > /career-ops

• Antigravity CLI

  agy
  > /career-ops

Headless and Batch Execution

For automation and CI/CD pipelines, use the headless command structure where each CLI passes the prompt directly:

claude -p "scan"
codex -p "scan"
opencode run "scan"
agy -p "scan"

These commands trigger the scan.mjs worker (or set-status.mjs for status operations) while respecting the tier mapping defined in your profile. The headless mode executes the same Node.js scripts used in interactive mode, ensuring behavioral consistency across automation and manual workflows.

Overriding Tiers for Single Executions

To temporarily bypass your profile's default tier for a one-off execution, prepend the tier selector directly to your prompt:

agy -p "[tier=premium] scan"

The bracket syntax [tier=premium] is interpreted by the shared skill engine in AGENTS.md and temporarily overrides the spend_tier value from config/profile.yml for that specific invocation. This allows you to access premium models on demand without modifying your persistent configuration.

Summary

• AI-agnostic architecture separates CLI entry points from core pipeline logic via wrapper files (CLAUDE.md, CODEX.md, OPENCODE.md, AGENTS.md) that inject environment-specific variables.
• Cost tier abstraction in modes/_shared.md maps economy, standard, and premium tiers to CLI-specific models, enabling consistent spending control across different agents.
• Centralized configuration through config/profile.yml sets the spend_tier and language.output values that all CLIs respect at runtime.
• Uniform execution allows the same scan or set-status commands to run identically in both interactive and headless modes across Claude Code, Codex, OpenCode, and Antigravity.

Frequently Asked Questions

Do I need to modify the core logic to add a new CLI?

No. The architecture in santifer/career-ops separates CLI-specific configuration from core pipeline logic. Adding support for a new CLI only requires creating a new entry file in the repository root (following the pattern of CLAUDE.md or CODEX.md) and registering it in docs/SUPPORTED_CLIS.md. The core skill logic in AGENTS.md and the tier mappings in modes/_shared.md remain untouched because they use abstract tier names rather than CLI-specific implementation details.

How does Career-Ops handle different API keys for each CLI?

Each CLI wrapper (CLAUDE.md, CODEX.md, etc.) functions as a thin script that loads the shared career-ops skill prompt while injecting CLI-specific environment variables. The wrapper files handle the authentication context for their respective providers (such as Anthropic for Claude Code or OpenAI for Codex) before forwarding execution to the common pipeline. Because these wrappers are version-controlled markdown files in the repository root, credentials are managed through standard environment variable practices without hardcoding sensitive data.

Can I mix different CLIs in the same project?

Yes. Because the runtime reads from config/profile.yml at execution time, you can run commands with Claude Code for interactive debugging, switch to OpenCode for batch processing, and use Antigravity for specific automation tasks—all within the same repository. The shared tier mappings ensure that a standard tier request consumes equivalent cost levels across all three tools, maintaining predictable spending regardless of which CLI executes the command.

What happens if a CLI doesn't support a specific tier?

The tier mapping in modes/_shared.md defines the closest available model for each CLI within the three abstract tiers. If a CLI lacks a direct equivalent for premium or economy, the mapping automatically falls back to the nearest capability level available for that provider. The runtime handles this selection transparently, so your scripts continue to function even when provider model lineups change, requiring updates only to the single row in _shared.md rather than throughout your codebase.

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