TrajectoryRL

# TrajectoryRL

> **Bittensor Subnet 11** — A reinforcement learning playground that continuously produces state-of-the-art skills for AI agents

[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
[![Bittensor](https://img.shields.io/badge/bittensor-7.0+-green.svg)](https://github.com/opentensor/bittensor)

Every platform shift creates a new software category. PCs gave us desktop apps. Smartphones gave us mobile apps. Agents are the next platform, and **skills are the software that runs on them**. The world needs far more skills than human developers can ship. Agents will write skills for other agents. TrajectoryRL is the RL playground where that happens.

The competition runs 24/7 on Bittensor. Miners compete every epoch to produce the best agent skills, validators evaluate them in real sandboxes with real protocols, and the winning skills surface automatically. Every season the bar rises. You don't bring us your prompt. **Skills ship, you install them.**

```bash
pip install trajrl
```

One install gives any agent (Claude Code, Cursor, Codex, OpenClaw, Hermes, Manus, …) access to every skill the subnet has shipped. Source, catalog, and docs: [`trajrl`](https://github.com/trajectoryRL/trajrl).

## Overview

```
┌──────────────────────────────────────────────────────────────┐
│                   TRAJECTORYRL SUBNET (SN11)                 │
│                                                              │
│  MINERS                              VALIDATORS              │
│  ┌───────────────┐                   ┌───────────────────┐   │
│  │ Write SKILL.md│   on-chain        │ Read commitments  │   │
│  │ Upload pack   │   commitment      │ from chain        │   │
│  │ to public URL │─────────────────> │                   │   │
│  │               │                   │ Fetch packs,      │   │
│  └───────────────┘                   │ verify hash       │   │
│        │                             │                   │   │
│        │                             │ Evaluate via      │   │
│        │                             │ trajrl-bench:     │   │
│        │                             │ run all scenarios │   │
│        │                             │ (Hermes inside    │   │
│        │                             │  scenario image)  │   │
│        │                             └───────────────────┘   │
│        │                                      │              │
│        │                                      │ set_weights  │
│        ▼                                      ▼              │
│  ┌──────────────────────────────────────────────────────┐    │
│  │              BITTENSOR BLOCKCHAIN                    │    │
│  │   Commitments, weights, TAO rewards                  │    │
│  └──────────────────────────────────────────────────────┘    │
└──────────────────────────────────────────────────────────────┘
```

- **No server required** — Miners upload packs to any HTTP endpoint and commit on-chain. No GPU, no uptime needed.
- **Quality-based competition** — Validators run a fixed set of shell-verifier scenarios (Terminal-Bench-format). The agent runs *inside* each scenario's container with all its system + python deps available; a fresh verifier container scores the agent's output via `pytest`. Quality is continuous (`passed_tests / total_tests` from the verifier's `ctrf.json`), final score is the equal-weighted sum across scenarios. Cost per scenario is reported as a separate axis.
- **Content-addressed** — Packs identified by SHA256 hash, verified against on-chain commitment.
- **Winner-take-all** — Best miner gets 100% of rewards; first-mover advantage protects early innovators.
- **Anti-copy** — NCD similarity detection + first-mover threshold.

## The Flywheel — Season 2: Skill Forge

Season 1 runs on hand-designed scenarios. Season 2 turns the subnet into an **agent-driven auto-research loop** — real user trajectories become the next generation of eval scenarios, auto-packaged by an agent, with no humans in the routine loop. Skills produce usage, usage reveals gaps, gaps become challenges, challenges produce better skills.

```
┌────────────┐    ┌────────────┐    ┌──────────────┐    ┌────────────┐    ┌─────────────┐
│ 1.SKILLS   │ →  │ 2.USERS    │ →  │3.TRAJECTORIES│ →  │4.CHALLENGES│ →  │5.COMPETITION│
│  install   │    │ run agents │    │  contribute  │    │  agent     │    │   miners    │
│            │    │ on real    │    │  (PII strip  │    │  packages  │    │   compete   │
│            │    │ work       │    │   → pool)    │    │  failures  │    │  → winner   │
└────────────┘    └────────────┘    └──────────────┘    └────────────┘    └─────┬───────┘
      ▲                                                                         │
      └─────────────────────────────────────────────────────────────────────────┘
                    winning SKILL.md publishes → users install → loop spins again
```

**① Install and run.** Users pull a SKILL.md, point their agent at real work. The skill either solves the job or doesn't.

**② Contribute.** `trajrl contribute` strips PII and pushes the session JSONL to a public pool. You earn TAO if your trajectory becomes a discriminating challenge.

**③ Auto-craft.** A packaging agent clusters failures, maps tools to sandbox services, writes new eval scenarios. No humans in the routine loop.

**④ Compete.** Miners rank on a growing pool they can't predict. General-purpose SKILL.md is the only winning strategy.

**⑤ Publish.** Winning SKILL.md hits the registry. Next cycle is harder — easy failures are already solved.

Contributors, miners, and validators share the same emission pool. Users install the winners and get better agents every cycle. The loop is agent-driven end to end — a packaging agent crafts scenarios, a judge agent grades competition, a meta-analyst agent watches what's under-represented in the pool. H