Loading
Loading
Incentivizing breakthroughs on decades-old open mathematical conjectures
Neuron registration trends
Software engineering evaluation at scale requires isolating agent behavior from human bias, capturing what an agent actually did (not what it claims it did), and producing trustworthy training data without leaking proprietary task details. Current approaches either rely on manual human review, publish full task/solution histories that miners can exploit, or lose critical intermediate steps (prompts, commands, edits) needed to retrain agents effectively. The solution is to distribute evaluation infrastructure so that task creation, agent execution, judging, and data export each remain independent. One validator generates tasks from real GitHub issues; agents (miners) attempt solutions in isolated Docker containers; a separate scoring layer compares solutions fairly; and a trusted event capture system records every LLM call, command execution, and code edit—preserving the complete trajectory for training while redacting sensitive task details. Bittensor's Ninja subnet implements this by running tau as the validator-side pipeline: it proxies all model calls through a controlled inference endpoint, instruments the Docker runner to capture token-faithful events, and exports training data (GRPO/DPO format) to private datasets while maintaining strict security boundaries between miner code and validator truth.
Use cases were auto-generated from the GitHub repository and may not reflect the latest changes.
tau is a validator-side software engineering evaluation pipeline for the Bittensor Ninja subnet. It handles task generation from GitHub repositories, manages Docker-based agent execution, runs LLM-powered judging, and coordinates king/challenger validation rounds with detailed rollout tracking. The system captures token-faithful LLM call trajectories, command execution events, code edits, and final patches to produce training data for offline reinforcement learning (GRPO/DPO) while maintaining strict security boundaries between miner-controlled agent code and validator-controlled scoring infrastructure.
tau implements a validator-side pipeline with three main layers: (1) Task Generation (task_generation.py, task_pool_manager.py) mines GitHub issues and creates isolated workspaces; (2) Solver Execution (docker_solver.py, solver_runner.py, openrouter_proxy.py) runs miner agents in Docker, proxies all LLM calls through OpenRouter, and captures token-faithful trajectories plus command/edit events via tau-owned runner instrumentation; (3) Validation & Scoring (validate.py, eval.py) runs king/challenger rounds, collects judge verdicts, and exports training data. The ninja agent (separate repo) provides only a solve(repo_path, issue, model, api_base, api_key) -> {patch, logs, steps, cost, success} contract; tau wraps and instruments that contract to extract training-grade trajectories while keeping the harness black-box. Rollouts are written to local JSONL and optionally pushed to private HuggingFace datasets with configurable redaction policies (public vs private visibility tiers).
This information was auto-extracted from the GitHub repository and may be incomplete or out of date. Always refer to the subnet's GitHub repository for the latest instructions.
tau orchestrates SWE task validation through a black-box harness model: miners submit solutions via the ninja agent which calls a validator-managed LLM proxy (OpenRouter). The validator runs the miner's agent in Docker isolation, captures full token-faithful LLM trajectories (prompts/responses), command execution events (stdout/stderr/exit codes), and code edits. An LLM judge (e.g., Claude Sonnet) compares the miner's final patch against a reference patch or king solution, producing a score and winner label.
Successful high-margin trajectories feed into GRPO training; winning/losing pairs feed into DPO training. Validators must keep all hidden task metadata and reference patches private during public export to prevent hill-climbing.
The sections above were auto-generated from the GitHub repository and may not reflect the latest changes. View repository
Incentivizing breakthroughs on decades-old open mathematical conjectures
agent repo: https://github.com/ninja-subnet/ninja
FAQs were auto-generated from the GitHub repository and may not reflect the latest changes.
Holder & total-staked metrics as of 1h ago (hourly snapshot)
Miners run the ninja agent (separate repo) which calls a validator-managed LLM endpoint; hardware depends on miner's chosen inference setup
Validators manage OpenRouter proxy, Docker container orchestration, LLM judging, and HuggingFace dataset uploads. Disk requirements scale with rollout storage (JSONL trajectories, task workspaces, artifacts)
Repository has moved; clone the validator repo (this is validator-side code, not miner code)
git clone https://github.com/ninja-subnet/ninja-validator
Install tau from source in development mode
pip install -e .
Set OpenRouter API credentials for LLM proxy
export OPENROUTER_API_KEY=<your-key>
Set HuggingFace credentials for dataset uploads
export HF_TOKEN=<your-token>
Run validator with rollout recording enabled (uses config flags from src/config.py)(optional)
tau validate --record-rollouts --rollout-root ./rollouts --push-rollouts-to-hf --rollout-hf-dataset ninja-rollouts
Run test suite to verify installation(optional)
python -m pytest tests/