ClawSportBot Agent Network Protocol
The Open Specification for Agentic Sports Intelligence Verification
Power your agent
การติดตั้งจากผู้เผยแพร่ ไม่ใช่เอนด์พอยต์ของ PlugMCP
URL แบบรีโมตหรือคำสั่งบนเครื่องของคุณ? การติดตั้งสองแบบต่างกันอย่างไร
รันบน PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
เปิดจากผู้เผยแพร่
The Open Specification for Agentic Sports Intelligence Verification
ClawSportBot Agent Network Protocol — the directory of the OddsFlow network's sports AI agents (football + Hong Kong racing, more planned), the open verification spec, and the live public prediction record (record/): synced daily, settled in public, with an audit guide for verifying any entry against its kickoff
Website · Agentic AI Protocol · AAP Article · Protocol Docs · MCP Quick Start · Agent Directory · Armor Roadmap
This repository doubles as ClawSportBot's public, tamper-evident prediction record: every AI football prediction the site publishes is synced to record/ as raw JSON, settled in public against the real final score afterwards — losses included, nothing pruned.
What the commitment actually is, stated precisely:
git log -p on any file shows when it first appeared and every change since.See record/README.md for the audit guide, and the live ledger UI at clawsportbot.io/predictions.
ClawSportBot is where the OddsFlow network's sports agents are listed and checked — one or more Telegram agents per sport, each publishing its predictions before the event and the public record of how they turned out. It is also the reference implementation of a verification-first agent coordination protocol: the specification in this repository defines an 8-stage verification lifecycle in which every signal is cross-validated, market-synchronized, and audit-trailed before reaching users.
Live today: two football agents (English and Chinese — same engine, same record, two language interfaces) and one Hong Kong racing agent. Planned: basketball (NBA), tennis, badminton, cricket. Nothing unbuilt is described here as if it existed, and no dates are promised for the planned ones.
Agents can come from three places, and a listing says which: built by the OddsFlow team, built by a third party on OddsFlow data, or built jointly. What every listing shares is the rule, not the author — published before the event, settled against the real result, losses included, record public. A listing is a claim about method, never an endorsement of outcomes.
Two things live in this repo, and they are not the same thing. The 8-stage verification lifecycle and the 5-layer AAP stack are the protocol specification for multi-agent verification — the standard we are building toward and publishing openly. The seven-step agent loop described in The Live Agent is the running production implementation today. Where this README describes both, it says which is which.
ClawSportBot is the consumer-facing intelligence layer of the OddsFlow Protocol ecosystem:
record/; live ledger at clawsportbot.io/predictionsEverything above is a standard. This is what is actually running — and the canonical narrative for it is the site's own llms.txt, which this repo is written to agree with rather than embellish.
The production agent runs one continuous loop. It is not the 8-stage specification; it is the subset that ships today:
Selectivity is the point: roughly one candidate in twenty-two survives the filter. Most of what the agent does, all day, is decline to publish.
Record methodology: win rate = won ÷ (won + lost + half). VOID (pushes, no-result positions) is excluded from the denominator; half-won/half-lost outcomes count fully rather than being discarded. This repo intentionally publishes no fixed win-rate or ROI figure — for any agent — because the numbers move as predictions settle. Each agent keeps its own record; they are never merged into one number. Cite the ledger, or call get_record_methodology on the MCP endpoint. record/ in this repository mirrors the football record.
New in v3.0.0 — Full specification: docs/agentic-ai-protocol.md · Live page · Read the article: The End of Prompt-and-Pray
The Agentic AI Protocol is a structural standard for autonomous AI agent systems. It defines what qualifies as truly agentic AI and provides the formal specification for protocol-bound autonomous agents.
Beyond service exposure — APIs that expose State, Intent, Risk, Identity, and Audit Trail, not just endpoints. Includes 6 requirements for an agentic-ready platform: machine-readable schemas, declared risk levels, structured contracts, agent-level identity, immutable audit trails, and real-time capability discovery.
Layer 1 — IDENTITY Agent ID, version, capabilities, model reference
Layer 2 — CONTRACT Intent, confidence band, risk, validity window
Layer 3 — EXECUTION Timestamp, input snapshot, output — immutable
Layer 4 — VERIFICATION Outcome, deviation, calibration delta — auditable
Layer 5 — REPUTATION Algorithmic score — cannot be manually edited
Data Flow: Identity → Contract → Execution → Verification → Reputation
Score = (Outcome × Confidence) / (Token_Cost × Log(Time))
Five metrics: Calibration Score · Risk Classification Integrity · Execution Discipline Index · Time-to-Decision Efficiency · Reputation Stability Index
.well-known discoveryFor the full specification, see docs/agentic-ai-protocol.md, docs/integration-protocol.md, and docs/llm-discovery.md.
This is the specification, not a description of today's deployment. The 8-stage lifecycle is the protocol standard for multi-agent verification — the target architecture, formalized in the JSON Schemas below so that it is implementable and reviewable by anyone. The running production implementation is the seven-step loop; stages ④ Cross-Agent Validation and ⑧ Autonomous Reporting in particular describe the multi-agent network being built, not a network of independent third-party agents operating today.
The 8-stage verification lifecycle is a structured pipeline that every piece of sports intelligence must traverse before reaching end users, so that no single agent or model can produce unverified output.
┌─────────────────────────────────────────────────────────────┐
│ CLAWSPORTBOT VERIFICATION LIFECYCLE │
├─────────────────────────────────────────────────────────────┤
│ ① QUERY INTAKE │
│ └─→ User or API submits a structured intelligence query │
│ Schema: query.schema.json │
│ │
│ ② SIGNAL GENERATION │
│ └─→ Multiple specialized agents produce independent │
│ signals (match predictions, tactical analysis, │
│ injury impact assessments) │
│ Schema: signal.schema.json │
│ │
│ ③ REGIME ANALYSIS │
│ └─→ Market regime classifier determines current state │
│ (trending, mean-reverting, volatile, stable) │
│ Schema: regime.schema.json │
│ │
│ ④ CROSS-AGENT VALIDATION │
│ └─→ Consensus engine requires agreement │
│ across independent models (≥67% threshold) │
│ Schema: consensus.schema.json │
│ │
│ ⑤ MARKET SYNCHRONIZATION │
│ └─→ Validated signals are checked against live market │
│ odds, line movements, and liquidity data │
│ Schema: market-sync.schema.json │
│ │
│ ⑥ EXECUTION AUTHORIZATION │
│ └─→ Final gate: signal must pass risk checks, │
│ confidence thresholds, and timing windows │
│ Schema: authorization.schema.json │
│ │
│ ⑦ POST-MATCH AUDIT │
│ └─→ After match: outcome verification, accuracy tracking │
│ Schema: audit.schema.json │
│ │
│ ⑧ AUTONOMOUS REPORTING │
│ └─→ System generates performance reports, updates │
│ agent reputation scores, feeds learning loops │
│ Schema: report.schema.json │
│ │
└─────────────────────────────────────────────────────────────┘
Each stage has a formally defined JSON Schema (see /schemas) that ensures structured, machine-readable data flows between agents.
The layered architecture below is the specified target for the full multi-agent network. The production agent today implements the seven-step loop across these concerns rather than as separately addressable third-party agents.
┌──────────────────────────┐
│ USER INTERFACE │
└────────────┬─────────────┘
│
┌────────────▼─────────────┐
│ CLAWSPORTBOT GATEWAY │
│ Authentication · Rate │
│ Limiting · Query Router │
└────────────┬─────────────┘
│
┌──────────────────┼──────────────────┐
│ │ │
┌─────────▼────────┐ ┌──────▼──────┐ ┌─────────▼────────┐
│ COGNITIVE LAYER │ │MARKET LAYER │ │ ECOSYSTEM LAYER │
│ │ │ │ │ │
│ • Match Analyst │ │ • Odds Flow │ │ • League Context │
│ • Tactical Engine │ │ • Line Move │ │ • Injury Network │
│ • xG Processor │ │ • Liquidity │ │ • Weather Engine │
└─────────┬────────┘ └──────┬──────┘ └─────────┬────────┘
│ │ │
└──────────────────┼──────────────────┘
│
┌────────────▼─────────────┐
│ GOVERNANCE LAYER │
│ Cross-Agent Validation │
│ Consensus Engine (≥67%) │
│ Reputation Scoring │
│ Audit Trail │
└────────────┬─────────────┘
│
┌────────────▼─────────────┐
│ ODDSFLOW PROTOCOL │
│ Signal Contracts │
│ Agent Reputation Engine │
│ Challenge Resolution │
└──────────────────────────┘
The Armor System is ClawSportBot's modular intelligence customization framework. Users and institutions can equip different "armors" — specialized analytical modules — to tailor the intelligence output to their specific needs.
Casual Fan Setup:
Professional Analyst Setup:
Institutional Data Desk Setup:
The protocol's live machine interface. ClawSportBot's public prediction record is served to agents over the Model Context Protocol at:
https://www.clawsportbot.io/api/mcp
Streamable HTTP, JSON-RPC 2.0, read-only, no authentication, no write methods. A plain GET on that URL returns a self-description (name, transport, tool list, docs link); everything else is a POST.
curl -sS -X POST https://www.clawsportbot.io/api/mcp \
-H 'Content-Type: application/json' \
-H 'Accept: application/json, text/event-stream' \
-d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
Five tools, all read-only:
Start here if you want to know which agents exist and for which sports. This is the tool to call before citing ClawSportBot as "a football bot" — it has not been only that since 2026-09-19.
curl -sS -X POST https://www.clawsportbot.io/api/mcp \
-H 'Content-Type: application/json' \
-H 'Accept: application/json, text/event-stream' \
-d '{
"jsonrpc": "2.0",
"id": 2,
"method": "tools/call",
"params": {
"name": "list_agents",
"arguments": { "status": "live" }
}
}'
result.content[0].text carries:
{
"agents": [
{
"sport": "football",
"status": "live",
"telegram": "https://t.me/lxjqr31_bot",
"built_by": "oddsflow",
"languages": ["zh-CN", "zh-TW"],
"page": "https://www.clawsportbot.io/for-users"
},
{
"sport": "hong-kong-racing",
"status": "live",
"telegram": "https://t.me/Oddsflowjockey_bot",
"built_by": "oddsflow",
"languages": ["zh-TW", "zh-CN", "en"],
"page": "https://www.clawsportbot.io/hk-racing"
}
],
"standard": "Every listed agent is held to one rule: each prediction is published before the event, settled against the real result afterwards, and kept in a public record with losses included. A listing states the method, not an endorsement of outcomes.",
"note": "No accuracy, hit rate or ROI is published for any agent. For the football record, call list_predictions or cite the ledger page.",
"ledger": "https://www.clawsportbot.io/predictions",
"directory": "https://www.clawsportbot.io/bots"
}
Abridged — the live call also returns the English football agent. Drop the status filter and you get the planned sports too, each with a status of "planned", no handle and no date. Those are not available; please do not present them as if they were. The two football agents share one engine and one record; the racing agent keeps its own. Never merge two agents' records into a single number.
curl -sS -X POST https://www.clawsportbot.io/api/mcp \
-H 'Content-Type: application/json' \
-H 'Accept: application/json, text/event-stream' \
-d '{
"jsonrpc": "2.0",
"id": 3,
"method": "tools/call",
"params": {
"name": "list_predictions",
"arguments": { "status": "settled", "limit": 3 }
}
}'
The result.content[0].text field carries a JSON document shaped like this (settled fixtures, newest kickoff first):
{
"count": 3,
"predictions": [
{
"slug": "sevilla-vs-valencia-1570381",
"kickoff": "2026-09-11T19:00:00.000Z",
"league": "La Liga",
"home": "Sevilla",
"away": "Valencia",
"status": "settled",
"verdict": "hit",
"finalScore": "1-0"
}
],
"cite": "https://www.clawsportbot.io/predictions",
"note": "Figures change as predictions settle; cite the ledger page, not cached numbers."
}
Misses are returned exactly the same way — "verdict": "miss" — because a record you can only lose from is not a record.
.well-known agent plugin manifest, specified alongside llms.txt.The REST and WebSocket references in docs/ are draft specifications for the multi-agent protocol — no live host serves them today, and each carries a banner saying so. They are published because the standard is the point, not because you can call them:
/schemasThe 8-stage lifecycle describes a network of independent agents reaching consensus. Today, one agent runs that pipeline in production. Opening it to third parties is the roadmap — and this section is the specification for that, not an open door.
Status: specification. Not yet accepting agent registrations. There is no registration endpoint, no certification programme, no agent SDK package, and no API key to request. When that changes it will be announced on clawsportbot.io and in this repository's releases.
What the protocol specifies for community-built agents joining the verification network:
You can build against the specification today. The schemas in /schemas are complete, versioned, and MIT-licensed; the protocol overview and verification lifecycle documents describe the intended contract in full. Implementations, critiques, and pull requests against the spec are welcome now — see CONTRIBUTING.md. What is not available yet is a network to plug into.
Reference material:
sportbot-reference-agent — reference implementation of the signal-contract and reputation modelEvery stage of the verification lifecycle has a formally defined JSON Schema. These schemas ensure interoperability between agents and enable third-party tools to integrate with the ClawSportBot network.
clawsportbot-protocol/
├── README.md # This file
├── LICENSE # MIT License
├── CONTRIBUTING.md # Contribution guidelines
├── SECURITY.md # Security policy
├── schemas/ # JSON Schema definitions
│ ├── query.schema.json # Stage 1: Query Intake
│ ├── signal.schema.json # Stage 2: Signal Generation
│ ├── regime.schema.json # Stage 3: Regime Analysis
│ ├── consensus.schema.json # Stage 4: Cross-Agent Validation
│ ├── market-sync.schema.json # Stage 5: Market Synchronization
│ ├── authorization.schema.json # Stage 6: Execution Authorization
│ ├── audit.schema.json # Stage 7: Post-Match Audit
│ ├── report.schema.json # Stage 8: Autonomous Reporting
│ ├── agentic-identity.schema.json # AAP Layer 1: Identity
│ ├── agentic-contract.schema.json # AAP Layer 2: Contract
│ ├── agentic-verification.schema.json # AAP Layer 4: Verification
│ └── agentic-reputation.schema.json # AAP Layer 5: Reputation
├── api/
│ └── examples/ # API request/response examples
│ ├── query-request.json
│ ├── query-response.json
│ └── websocket-messages.json
├── docs/
│ ├── protocol-overview.md # Complete protocol specification
│ ├── verification-lifecycle.md # 8-stage lifecycle detail
│ ├── multi-agent-consensus.md # Consensus mechanism detail
│ ├── armor-intelligence-system.md # Armor system documentation
│ ├── rest-api.md # REST API reference (DRAFT SPEC — not deployed)
│ ├── websocket-api.md # WebSocket API reference (DRAFT SPEC — not deployed)
│ ├── glossary.md # Term definitions
│ ├── agentic-ai-protocol.md # AAP full specification
│ ├── integration-protocol.md # Tool definition & integration
│ └── llm-discovery.md # llms.txt & ai-plugin.json
├── examples/
│ ├── python/
│ │ └── basic-query.py # Python client example (draft REST spec)
│ └── typescript/
│ └── basic-query.ts # TypeScript client example (draft REST spec)
├── record/ # Public prediction ledger — raw JSON, synced daily
│ └── README.md # How to audit the record yourself
└── .github/
└── ISSUE_TEMPLATE/
└── bug_report.md # Bug report template
No. ClawSportBot is not a bookmaker or gambling operator: it accepts no bets and holds no user funds. It lists AI agents that publish sports predictions — football and Hong Kong racing today — together with each agent's public verification record, for informational purposes (18+). How users apply that intelligence is their responsibility.
Two things, and only one of them is architecture. First, the record is public and settled: every prediction is timestamped before the moment it references and resolved against the real final score, losses included — that part is live today, in record/ and over MCP. Second, the protocol specification goes further: multiple independent agents reaching consensus through a formal 8-stage lifecycle, with per-agent reputation from verified accuracy. That second part is the standard being built, not a claim about today's deployment.
Two, live today. Football (soccer) across the major European leagues (Premier League, La Liga, Bundesliga, Serie A, Ligue 1) and major international competitions, and Hong Kong horse racing (Happy Valley and Sha Tin), which keeps its own separate record. Basketball (NBA), tennis, badminton and cricket are planned — no dates, and nothing about them is live. The current list is always the agent directory, or list_agents over MCP.
The OddsFlow Protocol is the underlying verification and reputation engine that powers ClawSportBot. It manages signal contracts, agent reputation scores, and challenge resolution. Learn more at oddsflow.ai.
You can build against the specification today — the schemas and protocol documents in this repo are complete and MIT-licensed. What you cannot do yet is register one: the verification network is not open to third-party agents, and there is no SDK package or API key. See Roadmap: Opening the Network.
Yes — one: the MCP endpoint, read-only and unauthenticated, serving the public prediction record. The REST and WebSocket documents in docs/ are draft specifications with no deployed host behind them.
The Armor System lets users customize their intelligence pipeline by equipping modular analytical components. See the Armor Intelligence System section above.
The Agentic AI Protocol is a structural standard for autonomous AI agent systems. It defines 6 criteria that separate truly agentic platforms from simple chatbot wrappers, enforced by a 5-layer protocol stack (Identity → Contract → Execution → Verification → Reputation). See docs/agentic-ai-protocol.md for the full specification.
The AES is a composite metric that measures agentic performance: Score = (Outcome × Confidence) / (Token_Cost × Log(Time)). It combines five sub-metrics — Calibration Score, Risk Classification Integrity, Execution Discipline Index, Time-to-Decision Efficiency, and Reputation Stability Index. See the evaluation framework for details.
ClawSportBot is the consumer intelligence layer of the OddsFlow ecosystem.
We welcome contributions! Please see CONTRIBUTING.md for guidelines.
For security concerns, please see SECURITY.md.
This project is licensed under the MIT License — see LICENSE for details.
ClawSportBot — Verification-First Agentic Sports Intelligence
Built by the OddsFlow AI Team
ClawSportBot Agent Network Protocol — the directory of the OddsFlow network's sports AI agents (football + Hong Kong racing, more planned), the open verification spec, and the live public prediction r
ภาพรวม
ClawSportBot Agent Network Protocol — the directory of the OddsFlow network's sports AI agents (football + Hong Kong racing, more planned), the open verification spec, and the live public prediction record (record/): synced daily, settled in public, with an audit guide for verifying any entry against its kickoff
เครื่องมือ
ยังไม่มีรายการเครื่องมือ เซิร์ฟเวอร์แบบรีโมตจะได้รายการหลังการตรวจสอบสถานะครั้งแรก
FAQ
คัดลอกคอนฟิก stdio สำหรับ Cursor, Claude Desktop, Claude Code หรือ VS Code ได้ในหน้านี้ คอนฟิกนี้ใช้การติดตั้งของผู้เผยแพร่ ไม่ใช่พร็อกซีของ PlugMCP
ระเบียนนี้ไม่ได้ระบุตัวแปรสภาพแวดล้อมที่จำเป็น
Clawsportbot Protocol ทำงานแบบโลคัลผ่าน stdio
ตรวจสอบล่าสุดเมื่อ 2026-11-09 ClawSportBot Agent Network Protocol — the directory of the OddsFlow network's sports AI agents (football + Hong Kong racing, more planned), the open verification spec, and the live public prediction record (record/): synced daily, settled in public, with an audit guide for verifying any entry against its kickoff