Guide · Agent skill

How to use the Test Reasoning Serialization agent skill

Updated 2026-11-02 · written with AI from the project's own documentation and checked against our catalogue data

The test-reasoning skill is an agent skill for the forge codebase. It gives your coding agent a ready-made test suite that checks whether reasoning settings such as effort, max tokens and thinking options are serialized into the correct JSON fields for OpenRouter, Anthropic, GitHub Copilot and Codex. This guide is for maintainers and contributors who work on forge's reasoning configuration, and it explains what the skill does, how to install it, how to trigger it and what to watch out for before running it.

Test Reasoning Serializationtailcallhq/forgecode · Apache-2.0 Download the skill

Quick start

1Download the ZIP. Download the test-reasoning ZIP from this page.
2Unzip into a skills folder. Unzip it into ~/.claude/skills/ for personal use, or into a project's .claude/skills/ folder.
3Check prerequisites. Make sure you have a Rust toolchain, a Bash shell and forge provider credentials for the providers you want tested.
4Ask the agent to run the tests. Make a natural request such as asking it to run reasoning tests for forge.
5Review the results. Check the pass or fail output per provider and model, and inspect .forge/forge.request.json for single-case debugging.

What is an agent skill and what does test-reasoning make the agent do?

An agent skill is a folder containing a SKILL.md file and optional scripts that an AI agent can load when a request matches the skill's description. The test-reasoning skill is scoped to validating that ReasoningConfig fields reach provider APIs in the right shape.

When the skill is active, the agent can run a test suite that builds the forge tool in debug mode, sends test requests to several providers, captures the outgoing request body and checks that reasoning or thinking settings appear in the expected JSON fields. It also confirms that an invalid effort value is rejected before any request is sent.

Builds target/debug/forge
Runs each provider and model combination in the coverage table
Captures the request body through FORGE_DEBUG_REQUESTS
Asserts the expected JSON field for each case

How do you install the test-reasoning skill?

You can install the skill in one of two ways. For personal use with Claude Code, download the ZIP from this page and unzip it into ~/.claude/skills/. To scope it to one project, unzip it into the .claude/skills/ folder inside that project instead.

In the Claude apps you can instead upload the ZIP under Settings → Capabilities → Skills.

Personal: ~/.claude/skills/
Single project: .claude/skills/ inside the project
Claude apps: Settings → Capabilities → Skills, then upload the ZIP

What do you need before running the tests?

The skill builds forge from source, so you need a Rust toolchain and a Bash shell. The script also uses mktemp and standard Unix tools. You must have forge's provider API credentials configured for each provider you want tested. Providers without credentials are skipped automatically, and the invalid-effort tests run regardless of credentials.

Rust toolchain (to build target/debug/forge)
Bash shell
mktemp and standard Unix tools used by the script
Provider API credentials configured for forge: OpenRouter, Anthropic, GitHub Copilot, Codex

How do you trigger the skill with a natural request?

The skill loads when your request matches its description. Plain requests about reasoning serialization work well, for example asking the agent to test reasoning serialization, run reasoning tests, verify reasoning config fields or check that ReasoningConfig maps to provider JSON.

If you only want to check one case, you can ask the agent to run a single test manually. The skill's manual method sets the provider, model and effort through environment variables, runs target/debug/forge with a short prompt and then inspects .forge/forge.request.json.

"Run the reasoning tests for forge."
"Verify that the reasoning effort field reaches OpenRouter correctly."
"Check that ReasoningConfig maps to the Anthropic thinking JSON."

FORGE_DEBUG_REQUESTS="forge.request.json" \
FORGE_SESSION__PROVIDER_ID=<provider_id> \
FORGE_SESSION__MODEL_ID=<model_id> \
FORGE_REASONING__EFFORT=<effort> \
target/debug/forge -p "Hello!"

What does the full test run cover?

The coverage table in the skill lists each provider, model, config field and the JSON field that should contain the value. OpenRouter cases check reasoning.effort, reasoning.max_tokens and reasoning.enabled, plus .exclude where relevant. Anthropic cases check output_config.effort for claude-opus-4-6 and thinking.type with budget_tokens for claude-3-7-sonnet-20250219. GitHub Copilot checks top-level reasoning_effort, and Codex checks reasoning.effort and reasoning.summary.

Running the whole script with ./scripts/test-reasoning.sh executes all of these cases in one pass.

OpenRouter: reasoning.effort, reasoning.max_tokens, reasoning.enabled, .exclude
Anthropic: output_config.effort, thinking.type and budget_tokens
GitHub Copilot: reasoning_effort at the top level
Codex: reasoning.effort, reasoning.summary
Invalid effort: non-zero exit and no request written

./scripts/test-reasoning.sh

What should you watch out for?

This skill is meant for maintainers verifying the forge codebase, not for general users of the tool. The tests can make real provider requests, which may incur cost, and the script reads credentials from the environment. Run it deliberately, ideally with accounts you are comfortable using for testing.

The skill also only covers reasoning fields. It does not test other providers or other features of forge.

Real requests may be sent and could incur cost
The script reads credentials from the environment
Scripts run and network is used
Coverage is limited to reasoning fields

What people use it for

Confirm that a new reasoning effort value reaches the OpenRouter request body in reasoning.effort.
Check that Anthropic thinking settings appear as thinking.type and budget_tokens after an API change.
Debug why a reasoning setting set in the environment is not reaching a Codex or Copilot request.
Verify that an invalid effort value fails before any request is sent.

Frequently asked questions

How do I install the test-reasoning agent skill?

Download the ZIP from this page and unzip it into ~/.claude/skills/ for personal use, or into a project's .claude/skills/ folder. In the Claude apps, upload the ZIP under Settings → Capabilities → Skills.

What do I need to run the test-reasoning skill?

You need a Rust toolchain to build target/debug/forge, a Bash shell, mktemp and standard Unix tools, and provider API credentials configured for forge. Providers without credentials are skipped.

Is the test-reasoning skill free to use?

The source lists the licence as Apache-2.0. The source does not state pricing, but running the tests can make real provider requests that may incur cost.

Does the skill work with providers other than OpenRouter, Anthropic, GitHub Copilot and Codex?

No. The skill covers only those four providers and reasoning fields. It does not test other providers or other features.

Why does the test-reasoning skill say it is not for general users?

It tests forge's internals, specifically how ReasoningConfig is serialized. General users who only want to run forge do not need it to use the tool.

Why does the invalid effort test run without credentials?

The rejection happens when the config is parsed, before any provider interaction, so no credentials are needed for those tests.

New agent skills, repos and AI tools — every week

The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.

Our verdict

Use test-reasoning if you contribute to the forge repository or maintain its provider integrations and need to confirm reasoning settings land in the right JSON fields. Skip it if you only want to use forge, or if you need to test providers or features beyond reasoning, since the skill does not cover them and its real requests can cost money.

Download the skill