Two direct API requests returned the exact text I asked for. A separately configured Codex CLI returned a reply, too. It would have been tempting to write “Codex and Claude Code are now connected to T3 Code through Crazyrouter.” That would overstate the test. The new T3 Code instances had not completed a task end to end, and the isolated Claude Code CLI setup had not completed its check.

At the same time, I had already used existing Codex and Claude Code providers in T3 Code to build two versions of an offline webpage. Those providers did work. Their success says nothing about whether a newly added API route works. This article is about keeping those claims apart while setting up a useful two-agent workflow.

The practical payoff is simple: if a new thread does not produce a reply, you want to know whether to inspect the key, the model ID, the CLI, the selected execution environment, or the project itself. “The provider is in the settings menu” is only one observation.

The four checkpoints hidden inside “the provider works”

T3 Code is an open-source interface for managing coding agents. Codex and Claude Code are the agents that actually read and modify files. T3 Code organizes the project, the selected provider, the task conversation and the working directory. Its terms are useful once they are tied to an observable check:

  1. API route: Does a direct request with the chosen key and model return visible text?
  2. Agent CLI: Can the corresponding CLI start with the intended configuration and receive a reply?
  3. T3 Code thread: Can a new thread select that provider instance and get a real reply?
  4. Project action: Can the agent read the intended project and complete a controlled file task?

Passing checkpoint one does not establish checkpoints two through four. A CLI reply still does not prove the T3 Code instance selected the same configuration. A provider card in Settings does not prove any model call occurred. Treat each checkpoint as a separate result, and stop troubleshooting at the first one that fails.

There is a second separation when you run two agents. A thread keeps a task's conversation distinct. A Git worktree keeps its files in a separate working directory within the same repository. Two threads can still point at one directory. If both jobs might create or change index.html, give each file-changing task its own worktree before starting them.

Set up T3 Code on the environment that will run the agents

The T3 Code installation guide gives Windows users a desktop option and a CLI plus local web option. For the desktop app, use winget install T3Tools.T3Code when winget is available, or get the Windows build from GitHub Releases. For the CLI route, run irm https://t3.codes/install.ps1 | iex in PowerShell, then start t3. You only need one entry point to begin.

I used an existing T3 Code v0.1.10 installation. I did not reinstall it during this test, so those commands are documented setup routes rather than a fresh installation result from this machine. Once the app is open, add the local Git project you intend to use.

Now check where the thread will execute. If it runs on Windows, the relevant Codex or Claude Code CLI and authentication must be prepared there. If it runs in WSL, prepare them in the selected WSL environment. A CLI installed in the other environment may be invisible to the thread. This detail is worth checking before changing model settings, because a missing executable and a rejected API request require different fixes.

Open Settings → Providers. Prepare the Codex and Claude Code CLIs separately and complete the authentication method used by each instance. When you create a thread, select the instance you intended to test. If the CLI cannot be found, inspect PATH in that execution environment. The official Codex provider guide and Claude Code provider guide also cover setting a Binary path explicitly.

T3 Code Settings with Providers and Worktrees in the sidebar

The Settings page shows where provider and worktree controls live.

Before assigning a code task, send the newly selected instance a request that does not edit files. Wait for an actual reply. If that succeeds, ask it to read a temporary project. Only after the read succeeds would I use it for a file-changing task. This order does not guarantee every future job will work, but it locates the first failing layer without risking confusion over a half-written project.

Configure the Codex and Claude Code API routes separately

Crazyrouter can provide the model API used by either agent. The two agents do not use the same base URL convention, so a shared key does not mean one shared instance configuration. Confirm that the key has permission for the exact model IDs before entering them in T3 Code.

Codex uses Responses. On Windows, make a separate .codex-crazyrouter directory under the user profile and place config.toml in it. Create a new Codex instance in T3 Code and point CODEX_HOME path at that directory. This keeps the existing Codex login settings in their original location. In config.toml, set model_provider = "crazyrouter"; inside [model_providers.crazyrouter], set name = "Crazyrouter", base_url = "https://api.crazyrouter.com/v1", env_key = "OPENAI_API_KEY", and wire_api = "responses". The top-level model must be an ID your key can use. The Crazyrouter Codex guide has the complete TOML structure.

Put the key itself in this T3 Code instance's Environment variables as OPENAI_API_KEY, and mark the value Sensitive. Do not put it in config.toml, a screenshot or a published command. Save the instance and select it from a new thread for the first no-edit test.

Claude Code uses Messages. Create a separate Claude instance and give it an independent CLAUDE_CONFIG_DIR path. In that instance's Environment variables, set ANTHROPIC_BASE_URL to https://api.crazyrouter.com, set ANTHROPIC_AUTH_TOKEN to the Crazyrouter key and mark it Sensitive, leave ANTHROPIC_API_KEY empty to avoid an older value taking precedence, and set ANTHROPIC_MODEL to a Claude model ID available to that key. Put the URL and key in the environment-variable fields, not in Launch arguments.

Crazyrouter's Claude Code configuration fields and base URL rule

Codex's base URL ends at /v1. Claude Code adds /v1/messages itself, so its base URL stops at the root domain. Copying the Codex URL into the Claude instance would point the request at the wrong path. The Crazyrouter Claude Code integration guide documents this distinction.

Keeping two configuration directories also helps with reversibility. If one experiment fails, the previously working Codex or Claude Code instance can remain available while you correct the new one. It also makes the next test unambiguous: start a fresh thread and explicitly select the new instance rather than assuming the model picker changed automatically.

What the November 19 checks established

Here is the evidence in the order it was obtained:

  • A direct request to Crazyrouter's /v1/responses with gpt-5.1-codex-mini returned the requested text.
  • A direct request to /v1/messages with claude-haiku-4-5 also returned the requested text.
  • Codex CLI launched with an isolated configuration directory and produced a reply.
  • Existing Codex and Claude Code providers in T3 Code completed a separate two-agent HTML task.

The first two results show that those API routes returned content under the tested key and model IDs. The third reaches the Codex CLI layer. The fourth shows that the existing T3 Code providers could perform the HTML task. It does not test the new Crazyrouter-backed instances.

The isolated Claude Code CLI check and an end-to-end task from either newly configured Crazyrouter instance inside T3 Code remained unfinished. Therefore, the strongest supported setup claim is that the two API routes and one isolated Codex CLI configuration responded in this local run. The complete new-provider path needs another test.

If a new thread fails, I would check the model ID and key permission, then the base URL required by that agent, then whether the CLI launches in the selected environment, and finally whether the thread selected the intended instance. Once it replies, I would let it read a temporary project before allowing file edits. This sequence turns an ambiguous “it doesn't work” report into a failing step someone can act on.

I would record the next attempt as a small table with one row per checkpoint: the selected instance name, execution environment, model ID, time, action and visible outcome. The key value should never enter that record. For the first T3 Code thread check, a prompt such as “Reply with the word ready; do not open or edit files” gives an observable response without involving a repository. The next prompt can name a harmless file in a temporary project and ask the agent to report its first line. If either step fails, keep the error message and stop there. If both pass, a reversible file edit becomes a meaningful final check. This record would show exactly which new instance worked, instead of borrowing confidence from the older providers or the direct API calls.

Use separate worktrees when both agents can change the same files

The two-agent task was deliberately small. Each agent had to produce an offline topic-list page where a user could add an article title and publication platform, mark a topic complete, filter by status, reload without losing entries, see an empty-state message and use the page on a narrow screen. I gave both existing providers the same functional request in separate threads and assigned separate worktrees for the file-changing work.

Both agents returned an index.html that opened offline and passed the basic add, toggle, filter and persistence interactions checked for this exercise. Their input controls differed: the Codex version accepted free text for the publication platform, while the Claude Code version used a dropdown. That is a product choice, not a benchmark result. A team that needs arbitrary platform names may prefer one behavior; a team that wants controlled labels may prefer the other.

The separate worktrees made the comparison possible without one index.html replacing the other. They did not review either page. For that, I asked Claude Code to read Codex's files. It identified a possible lost update when two browser tabs edit the topic list concurrently: one tab's older in-memory list can overwrite a newer stored change from the other tab.

That finding belongs to the generated page, not to T3 Code's task storage. I did not send Codex a repair request or verify a fixed build. The useful next step would be to record the exact two-tab sequence, request a change and repeat the same sequence on the repaired file. Until then, “found a defect” is the accurate result.

For this kind of handoff, the bug report should identify the artifact and the action, not just the agent that produced it. I would name the Codex worktree, state that the page uses browser storage, describe which tab held the older list, and say which new item disappeared after the later save. I would also preserve the original acceptance checks: a fix for simultaneous tabs should not break adding, filtering, or persistence after reload. That turns a cross-agent observation into a concrete repair request. It also makes the follow-up comparable with the first run, because both agents can be judged against the same visible behavior instead of a revised prompt that quietly changes the task.

There is no requirement to send every output through a second agent. The reason to do it here was specific: both pages met the short list of basic interactions, and I wanted another pass over the files before choosing one. For a single low-risk change, opening the artifact and checking the requested action may be enough. For two competing implementations, the separate worktrees make a second look possible without losing either candidate. Review effort should follow the risk and the decision you actually need to make.

For parallel tasks in a real project, this is the contract I would use: specify observable acceptance actions, give each file-changing thread a worktree, open both outputs yourself, and send reproducible failures back to an agent. T3 Code keeps the assignment and files organized. The judgment about what to merge still rests with the person responsible for the project. The T3 Code thread and worktree documentation covers the UI side of that flow.