Operation Guide and Mechanism Docs

Install and check this machine

uv tool install --python 3.12 techtree==0.1.1
techtree doctor --climb hello-world-climb@1

Doctor checks prerequisites and prints the next action. It does not start paid model inference.

Run the first Climb

Prepare the fixed comparison with the Skill you want to test. The preparation output shows the exact one-time start command and the model-spend ceiling before anything runs.

techtree climb prepare hello-world-climb@1 --skill path/to/skill

Approve and run only the exact techtree climb start command printed by preparation. Closing the terminal does not stop a started Run.

Use Hermes

The Hermes plugin is an operator interface over the same CLI. Give it this instruction:

Hermes may prepare commands and explain output. Techtree still stops before a paid model call and requires explicit approval.

Verify a Result locally

Verification reads a Result bundle, recomputes its checks, and makes no model call.

techtree proof verify path/to/result-bundle

Read exactly what verification establishes.

Publish a Result

Publishing is a separate action performed after a Run finishes. The CLI shows the publication terms and asks before it sends the Result bundle.

techtree publish RUN_ID

The server returns a signed publication receipt and repeated publication of the same bundle is idempotent. Published comparisons appear in Results.

Use the machine interface

Pass --json to CLI commands for one machine-readable envelope on stdout. Machine mode does not prompt; operational messages go to stderr.

Release bootstrap

GET /api/v1/bootstrap

Published Climb catalog

GET /api/v1/catalog

One Climb

GET /api/v1/climbs/:slug

Published Results

GET /api/v1/publications

One published Result

GET /api/v1/publications/:digest

Publication key

GET /api/v1/publication-keys/:key_id

Protocol payloads retain their schema field names even where the public site uses simpler words.

Know what leaves the machine

Local Runs, Episodes, and Traces stay local. Model calls go to the provider selected by the Climb. Techtree receives a Result bundle only when you explicitly publish it.

No Techtree account or browser upload is required.

Troubleshoot from the boundary inward

1. Run Doctor for the exact Climb reference.
2. Read the next action and any missing prerequisite it reports.
3. Use techtree run status RUN_ID for a started Run.
4. Use techtree run logs RUN_ID for execution details.
5. Re-run local verification before attempting publication again.

Source and issue tracking live at github.com/regents-ai/techtree.

Method

Most agent improvements are anecdotes.

Someone changes a prompt or a Skill, runs a few examples, and says the agent feels better. But many other things may have changed at the same time: the model, the harness, the tools, the task set, or the budget.

Techtree starts with a narrower question:

Did changing this one Skill make the agent better?

The second question is just as important:

How can someone else check the result without running the whole evaluation again?

Techtree v0.1 is our first answer.

The proof bundle

A Techtree proof contains the signed comparison, the task-level results, the exact task membership, and the fingerprints of the files used to produce the claim.

Anyone holding the bundle can verify it offline:

techtree proof verify path/to/result-bundle

No model call is needed. The verifier does not need to contact Techtree.

It checks that:

• the files still match their recorded hashes;
• the signatures are valid;
• the Result names a published Climb;
• both branches used the same ordered tasks;
• only the permitted Skill changed;
• the reported wins, losses, ties, and totals recompute from the task results;
• the bundle satisfies its publication policy;
• no private episodes, transcripts, or machine-local paths were included.

This is useful because a copied bundle can be checked independently of the website that published it.

The proof is participant-attested

It proves that the stored evidence is signed, internally consistent, and describes the controlled comparison it claims to describe.

It does not prove that:

• Techtree witnessed the run;
• the participant’s machine behaved honestly;
• the Result generalizes beyond this Climb;
• another party reproduced it;
• the Skill will help every model, harness, or environment.

Those are different claims.

Independent reproduction requires another participant to run the same scientific contract and publish a separately attributable result. Stronger claims about the machine itself would require stronger execution attestation.

Techtree keeps these questions separate rather than calling every valid signature “independent verification.”

The introductory v0.1 benchmark

It is intentionally simple.

It contains a Skill that clearly helps relative to the baseline. This makes it easy to see whether the machinery is working:

No tested Skill
    ↓
Starter Skill
    ↓
Measured difference
    ↓
Signed receipt

The benchmark is not meant to establish broad agent capability. It is a mechanism test for the complete local path:

• install the tools;
• prepare a controlled comparison;
• approve the model spend;
• run both branches;
• collect the Verifiers results;
• sign the proof;
• verify it offline.

The point is to show that an ordinary user can run the whole experiment on their own machine without trusting a Techtree server.

An agent is more than a model

It also has a harness, Skills, tools, memory, runtime rules, and an environment in which it works. Each of these can affect the outcome.

Techtree begins with Skills because they give us the cleanest comparison. But the same basic method can be applied more broadly:

Hold the benchmark fixed
→ improve the Skill

Hold the Skill and benchmark fixed
→ improve the harness

Hold the agent fixed
→ improve the environment

Hold the training setup fixed
→ compare which environment produces
  the best downstream improvement

The rule remains the same:

Freeze the system. Declare what may change. Measure the result. Preserve the evidence.

Environments in v0.2

Today, Techtree starts with a published benchmark.

In v0.2, it will also help create environments from material people and agents already produce:

• chat logs;
• agent traces;
• structured data;
• documents;
• repositories;
• notebooks;
• tool descriptions;
• expected outcomes.

These materials are not benchmarks by themselves. Techtree will turn them into qualified, content-addressed environments with explicit tasks, tools, verifier logic, data policies, and development and proving splits.

The executable target will be a Prime-compatible Verifiers environment.

Then Techtree can use development evidence to propose a better Skill, freeze that Skill, remove any temporary learning intervention, and compare Skill v1 with Skill v2 on untouched held-out tasks.

That produces a stronger claim than “the revision looked good”:

Skill v2 performed better than Skill v1 under the original controlled evaluator.

The agent stack

Later releases will broaden the systems Techtree can study.

NVIDIA NeMo Fabric will help run different agent harnesses through a common interface. NeMo Relay will help preserve and compare lifecycle evidence across model calls, tool calls, and subagents.

The division of labor is straightforward:

NeMo Fabric
run compatibility

NeMo Relay
trace compatibility

Prime Verifiers
task and reward compatibility

Techtree
study and proof compatibility

Prime Verifiers remains the authority for task results and rewards. Relay does not become a second scorer. Fabric does not become the environment format. Techtree records what was fixed, what changed, and what the evidence permits us to claim.

Techtree is the research and proof engine

Regents will provide the network around its artifacts: publishing, discovery, identity, reputation, rights, hosted execution, reproduction, and payments.

Future Results, Skills, environments, harness improvements, and reproductions may be shared or sold through x402-gated services. Agents that produce useful work will be able to build a track record and earn USDC.

But the economic layer depends on the research layer being honest first.

That is why Techtree starts here:

Same agent. Same tasks. One changed Skill. A receipt for the difference.

Give this instruction to your agent

Go to techtree.sh/start, install the pinned Techtree release, and run the Hello World Climb. Stop before any paid model call and ask me to approve it.

Start with Techtree · Browse Results