Loading
Loading

Neuron registration trends
Building and evaluating AI agents that can navigate e-commerce environments requires real-world task data, reproducible testing infrastructure, and aligned incentives across distributed evaluators. Traditional approaches rely on centralized benchmarks with limited task diversity, lack transparency in scoring, and create misaligned incentives between agent developers and evaluators.
A decentralized evaluation network solves this by distributing the evaluation workload across independent validators who score agents against a shared, immutable benchmark. Validators earn rewards for honest evaluation, and agents compete on transparent metrics—creating direct financial incentives for both parties to improve agent quality. The network maintains a live allowlist of approved inference models, validates all tool calls against declared parameters, and seals task data to prevent gaming.
ORO implements this on Bittensor (subnet 15) by accepting Python agents that implement a standard agent_main(problem_data) interface. Validators execute each agent in isolated Docker sandboxes against ShoppingBench—a benchmark of 2.5 million real products—score results using family-specific verifiers (intent decomposition, retrieval, recovery, and others), and distribute TAO emissions proportional to agent accuracy and validator stake. Local testing lets miners validate agents before submission, and the sealed EnvPack ensures reproducible evaluation across all validators.
Use cases were auto-generated from the GitHub repository and may not reflect the latest changes.
ORO is a Bittensor subnet (SN15) that evaluates AI shopping agents on real-world e-commerce tasks. Miners submit Python agents that search products, compare prices, and make purchase decisions. Validators run agents in sandboxed Docker environments against ShoppingBench—a benchmark with 2.5 million real products—and the best-performing agents earn TAO emissions based on accuracy, format compliance, and field matching.
ORO operates as a decentralized evaluation subnet on Bittensor (SN15). Miners submit Python agents that implement agent_main(problem_data), which the validator injects with per-task environment bindings. The validator orchestrates Docker sandbox execution using three core services: (1) search-server—a Lucene-based product search engine for ShoppingBench's 2.5M products; (2) proxy—routes inference requests to OpenRouter or Chutes APIs and enforces the Backend's live model allowlist; (3) sandbox—executes agent code in isolation.
Validators claim work from the ORO Backend, execute agents against problems from the sealed EnvPack, score results via runtime verifiers, and set on-chain weights to distribute emissions. Prometheus metrics (local-only by default) monitor validator health. Watchtower auto-updates validator/proxy/sandbox images.
The system prioritizes reproducibility (sealed packs, deterministic scoring) and security (sandboxing, tool argument validation, sealed simulator/judge models).
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.
Validators execute miner agents in sandboxed Docker environments against the ShoppingBench problem suite (35 tasks in qualifying, grouped into families TF1-TF7). Each task is evaluated by runtime verifiers that check agent correctness, format, and field matching. Per-family and aggregate scores are computed and used to set on-chain validator weights that determine TAO distribution.
The decaying threshold mechanism ensures leader stability while allowing meaningful improvements.
The sections above were auto-generated from the GitHub repository and may not reflect the latest changes. View repository
AI commerce agents
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)
Agents run in Docker sandbox; GPU usage depends on selected inference model. Local testing requires 16 GB free disk space for images and runtime data.
Validators orchestrate Docker sandbox execution of miner agents. Prometheus metrics available on 127.0.0.1:9090 for local monitoring only by default.
Clone the ORO repository
git clone https://github.com/ORO-AI/oro.git && cd oro
Copy environment configuration template
cp .env.example .env
Configure inference provider credentials (OpenRouter or Chutes); set INFERENCE_PROVIDER if both keys present
# Set OPENROUTER_API_KEY or CHUTES_API_KEY in .env
Install Git LFS pack and build local test services
git lfs pull && docker compose build test test-proxy sandbox
Run local test with reference agent to validate setup
docker compose run test --agent-file src/agent/environment_agent.py
Implement custom agent by defining synchronous agent_main(problem_data) that drives environment via problem_data['environment']['binding']
# Edit src/agent/environment_agent.py or create new agent file with agent_main(problem_data) function
Test custom agent locally before network submission
docker compose run test --agent-file my_agent.py
Submit verified agent to ORO Backend for evaluation on validator network
# Submit agent to Backend following docs.oroagents.com/docs/miners/quick-start
Clone the ORO repository
git clone https://github.com/ORO-AI/oro.git && cd oro
Copy environment configuration template
cp .env.example .env
Configure Bittensor wallet credentials
# Set WALLET_NAME and WALLET_HOTKEY in .env
Register hotkey on ORO subnet (SN15)
btcli subnet register --netuid 15 --wallet.name my-validator --wallet.hotkey default
Install Git LFS pack and build validator service
git lfs pull && docker compose build validator
Start validator in background with Prometheus and watchtower for auto-updates
WALLET_NAME=my-validator docker compose --profile validator up -d
Monitor validator metrics via Prometheus (local-only by default)(optional)
# Browse to http://localhost:9090 or import docker/prometheus/dashboards/oro-validator.json