Mert 
Covid-19’un BA.3.2 varyantı 30’dan fazla ülkeye yayıldı. Dünya Sağlık Örgütü bu varyantı “izlenmesi gereken varyant” sınıfına aldı. BA.3.2 Cicada varyantı nedir? Pandemi geri gelir mi?
Nothing, Android 17 öncesi Nothing OS 4.1 güncellemesini hazırlıyor. Yeni sürüm, yapay zekâ özellikleri ve arayüz iyileştirmeleriyle birlikte birçok modele gelecek.
Intel’in Arrow Lake Refresh işlemcileri satışa çıkmadan zamlandı. Core Ultra 7 270K Plus ve 250K Plus modelleri, önerilen fiyatların üzerine çıktı. İşte detaylar…
Türkiye, elektrik altyapısındaki güçlü hidroelektrik santral kapasitesi nedeniyle elektrik üretiminin yüzde 76’sını yenilenebilir enerji kaynaklarından karşılamayı başardı.
Çin, savaş senaryolarında dronları çok daha tehlikeli hâle getirebilecek hibrit bir sistem üzerinde çalışıyor. Hibrit dronlar, hem uzun mesafe kat edebiliyor, hem gerektiğinde sessiz uçabiliyor.
Çin ordusu, kentsel savaşlarda kullanılacak akıllı robot kurt sürülerini tanıttı. Bu dört ayaklı robotlar keşif, lojistik ve saldırı görevlerini bir arada otonom şekilde yürütebiliyor.Your Hyperliquid perpetual bot spotted the perfect setup — funding rates are paying 50% APR while spot is trading at a discount. But by the time you’ve manually signed into three different platforms, connected wallets, and navigated UIs, the opportunity is gone. Professional traders need infrastructure that executes as fast as they think.
Why Trading Infrastructure Matters
Every millisecond counts in crypto trading. Whether you’re running statistical arbitrage between Jupiter and centralized exchanges, or managing a complex delta-neutral strategy across perpetual futures and spot markets, your wallet infrastructure can make or break your edge. Manual wallet management, fragmented APIs, and missing risk controls turn profitable opportunities into costly delays.
The best traders automate everything — not just strategy logic, but the entire execution pipeline from signal generation to settlement confirmation. You need wallet infrastructure that speaks your language: REST APIs, policy engines, and multi-protocol access through a single interface.
Professional Trading Infrastructure with WAIaaS
WAIaaS provides the wallet infrastructure that serious trading operations require. Instead of managing multiple wallet connections and signing flows, your bot gets one REST API that spans 14 DeFi protocols across Solana and EVM chains — including Hyperliquid perpetuals, Jupiter swaps, and cross-chain bridges.
Hyperliquid Integration: Perps, Spot, and Sub-Accounts
Hyperliquid’s unified API covers perpetual futures, spot trading, and sub-account management. Through WAIaaS, your trading bot can execute complex strategies without dealing with wallet connection hassles:
# Open a 10x long position on ETH perpetual
curl -X POST http://127.0.0.1:3100/v1/actions/hyperliquid/place-order
-H "Content-Type: application/json"
-H "Authorization: Bearer wai_sess_<token>"
-d '{
"coin": "ETH",
"is_buy": true,
"sz": "1.0",
"limit_px": "3500",
"order_type": {"limit": {"tif": "Gtc"}},
"reduce_only": false
}'
Sub-accounts let you compartmentalize strategies while maintaining unified reporting:
# Create sub-account for delta-neutral strategy
curl -X POST http://127.0.0.1:3100/v1/actions/hyperliquid/create-sub-account
-H "Content-Type: application/json"
-H "Authorization: Bearer wai_sess_<token>"
-d '{
"name": "delta-neutral-arb"
}'
Multi-Protocol Trading Through One API
Professional strategies often span multiple venues. A typical delta-neutral play might involve shorting perpetuals on Hyperliquid while longing spot on Jupiter. WAIaaS handles the complexity:
# Step 1: Short ETH perp on Hyperliquid
curl -X POST http://127.0.0.1:3100/v1/actions/hyperliquid/place-order
-H "Authorization: Bearer wai_sess_<token>"
-d '{
"coin": "ETH",
"is_buy": false,
"sz": "2.0",
"limit_px": "3500"
}'
# Step 2: Buy ETH spot via Jupiter swap
curl -X POST http://127.0.0.1:3100/v1/actions/jupiter-swap/swap
-H "Authorization: Bearer wai_sess_<token>"
-d '{
"inputMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
"outputMint": "7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs",
"amount": "7000000000"
}'
Gas Conditional Execution
Gas costs can destroy trading profits, especially for high-frequency strategies. WAIaaS includes gas conditional execution — transactions only execute when gas prices meet your thresholds:
# Only execute when gas < 50 gwei
curl -X POST http://127.0.0.1:3100/v1/transactions/send
-H "Authorization: Bearer wai_sess_<token>"
-d '{
"type": "TRANSFER",
"to": "0x742d35cc1cf",
"amount": "0.1",
"gasCondition": {
"maxGasPrice": "50000000000"
}
}'
Your arbitrage bot queues transactions during high gas periods and executes automatically when conditions improve.
Risk Controls for Trading Bots
Automated trading requires automated risk management. WAIaaS’s policy engine provides 21 policy types including position size limits, leverage caps, and spending controls:
# Set max leverage for perpetual trading
curl -X POST http://127.0.0.1:3100/v1/policies
-H "X-Master-Password: my-secret-password"
-d '{
"type": "PERP_MAX_LEVERAGE",
"rules": {
"max_leverage": 10,
"markets": ["ETH", "BTC"]
}
}'
Position size limits prevent a single trade from risking the entire portfolio:
# Cap position sizes by market
curl -X POST http://127.0.0.1:3100/v1/policies
-H "X-Master-Password: my-secret-password"
-d '{
"type": "PERP_MAX_POSITION_USD",
"rules": {
"max_position_usd": 50000,
"per_market_limits": {
"ETH": 25000,
"BTC": 25000
}
}
}'
Real-Time Portfolio Monitoring
Trading bots need continuous position monitoring. WAIaaS tracks DeFi positions across all 14 integrated protocols:
# Get unified portfolio view
curl http://127.0.0.1:3100/v1/defi/positions
-H "Authorization: Bearer wai_sess_<token>"
This returns positions from Hyperliquid, Jupiter, Kamino, Drift, and other protocols in a standardized format. Your monitoring dashboard gets one API call instead of integrating with each protocol separately.
Cross-Chain Arbitrage Infrastructure
Inter-chain arbitrage requires reliable bridging. WAIaaS integrates LI.FI and Across protocols for seamless asset movement:
# Bridge USDC from Ethereum to Solana for Jupiter trading
curl -X POST http://127.0.0.1:3100/v1/actions/lifi/bridge
-H "Authorization: Bearer wai_sess_<token>"
-d '{
"fromChain": "ethereum",
"toChain": "solana",
"fromToken": "0xA0b86a33E6441",
"toToken": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
"amount": "1000000000"
}'
Your arbitrage bot can now capture opportunities across chains without manual intervention.
Quick Start: Deploy a Trading Bot
Here’s how to get trading infrastructure running in under 10 minutes:
1. Start WAIaaS with Docker
git clone https://github.com/minhoyoo-iotrust/WAIaaS.git
cd WAIaaS
docker compose up -d
2. Create wallets for your strategies
npm install -g @waiaas/cli
waiaas quickset --mode mainnet # Creates Ethereum + Solana wallets
3. Set up risk policies
# Create spending limits and position caps
curl -X POST http://127.0.0.1:3100/v1/policies
-H "X-Master-Password: <password>"
-d '{
"type": "SPENDING_LIMIT",
"rules": {
"instant_max_usd": 1000,
"daily_limit_usd": 50000
}
}'
4. Install the SDK in your trading bot
npm install @waiaas/sdk
5. Connect your bot and start trading
import { WAIaaSClient } from '@waiaas/sdk';
const client = new WAIaaSClient({
baseUrl: 'http://127.0.0.1:3100',
sessionToken: process.env.WAIAAS_SESSION_TOKEN,
});
// Your bot can now execute across 14 DeFi protocols
const balance = await client.getBalance();
const positions = await client.getDeFiPositions();
What’s Next
You now have professional-grade wallet infrastructure that scales with your trading operation. The complete WAIaaS documentation covers advanced topics like batch transactions, dry-run simulation, and integration with AI trading frameworks.
Ready to build? Get the code at GitHub or learn more at waiaas.ai.
The problem
AI agents choose between tools based on one thing: the quality of their descriptions.
Research shows 97% of MCP tool descriptions have quality defects (arXiv 2602.14878), and optimized tools get selected 3.6x more often (arXiv 2602.18914).
Most MCP developers don’t know their tool definitions are broken until an agent silently ignores them.
What I built
ToolRank scores MCP tool definitions across 4 dimensions:
It’s like Lighthouse, but for MCP tools.
GitHub Action — score on every PR
Today I published ToolRank Score on GitHub Marketplace.
Add this to your repo:
name: ToolRank Score
on:
pull_request:
paths: ['**/*.json']
permissions:
pull-requests: write
jobs:
score:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: imhiroki/toolrank-action@v1
On every PR that touches tool definitions, you get a comment like:
🟣
mcp.json— 95/100 (Dominant, top 3%)
Tool Score F C P E search_web95 25 33 23 14 Top issues:
search_web: No usage context — Add ‘Use this when…’ (+5pt)Scored by ToolRank v1.0.0
You can also set a minimum score and fail PRs that don’t meet it:
- uses: imhiroki/toolrank-action@v1
with:
min-score: 70
fail-on-low: true
REST API
If you want to integrate scoring into your own workflow:
curl -X POST https://mcp.toolrank.dev/api/score
-H "Content-Type: application/json"
-d '{"tools": [{"name": "search", "description": "Searches things"}]}'
Returns score, level, percentile, dimensions, and specific fix suggestions.
Ecosystem data
We scan 4,000+ MCP servers daily from Smithery and the Official MCP Registry. Some findings:
Check where your server ranks: toolrank.dev/ranking
What’s next
The scoring engine is fully open source. Star it if this is useful.
Try it
I’m building ToolRank as the quality standard for the MCP ecosystem. If you’re building MCP tools, I’d love to hear what you think.
Introduction
A common question developers ask when learning Go is: “Why goroutines when threads already work?” Take Java, for example—each client request is executed on an OS thread. Simple, straightforward, and battle-tested. So why did Go introduce this additional abstraction?
The answer lies in scalability and efficiency. While OS threads are powerful, they’re also heavyweight—creating thousands of them can overwhelm a system. Goroutines, on the other hand, are lightweight and managed by Go’s runtime, allowing you to spawn millions without breaking a sweat. But this raises another question: how does Go efficiently map thousands of goroutines onto a limited number of OS threads?
This is where Go’s ingenious GMP scheduling model comes into play.
The Challenge: Mapping Goroutines to Threads
OS threads are maintained by the operating system, which means the OS only knows about threads, not goroutines. Therefore, a goroutine must be mapped onto a thread to execute. This implies M:N mapping. At any given time, one thread handles one goroutine.
But how should this mapping occur? Let’s explore two approaches and their problems:
Approach 1: A Single Global Queue
Idea: A single global queue where threads push and pull goroutines concurrently.
Problem: This creates lock contention on the global queue. Each thread must acquire a lock, push or pull a goroutine, and then release the lock. Under high goroutine throughput, every thread is constantly fighting over the same queue. Each thread has to:
Approach 2: A Local Queue Per Thread
Idea: Give each thread its own local queue, eliminating contention on a shared structure.
Problem: Two issues arise. First, if a goroutine makes a blocking system call, the OS blocks that thread — all goroutines waiting behind it are now stuck, even though the CPU is free. Second, load becomes unbalanced: one thread’s queue may hold 100 goroutines while another’s is empty, and there is no rebalancing mechanism.
The Solution: The GMP Scheduling Model
The Go developers devised an elegant solution called the GMP scheduling model, which cleverly avoids these bottlenecks. The model consists of three key components:
The Three Components:
Important: There is still a global run queue in the GMP model, but it’s not the primary queue. It is used as a secondary queue.
What is a Processor (P)?
Instead of assigning queues directly to threads, Go uses distributed run queues owned by Ps. Each P maintains its own local run queue that holds multiple goroutines. Think of P as a scheduling context that bridges goroutines and threads.
Key relationships:
Understanding GOMAXPROCS: Tuning the Engine’s Parallelism
When are Goroutines and Threads Created?
Here’s the crucial insight: P controls parallelism. The number of Ps determines:
The GOMAXPROCS Setting
GOMAXPROCS determines the number of Ps in your program, and it can be manually configured.
Example scenario:
What happens:
The problem: With only 2 CPU cores but 4 threads, the OS must perform context switching between threads at the kernel level, which is relatively expensive.
Best practice: Set GOMAXPROCS = number of CPU cores (this is also the default in modern Go).
Thread Management: Creation, Parking, and Reuse
The scheduler doesn’t always create new threads. Here’s how Go optimizes thread management:
Scenario 1: Blocking System Call
When a goroutine makes a blocking system call:
Scenario 2: Subsequent Blocking Call
When another goroutine makes a blocking system call:
This parking and reusing strategy significantly reduces the overhead of thread management.
Scheduling Goroutines:
Scheduling loop:
When P needs to assign a G to the attached M, runtime runs this loop:
a. Every 61st goroutine — check global queue first — If a goroutine is found in the global queue, run it. If empty, proceed to b.
b. Check local queue — The P checks its own local queue. If a goroutine is found, run it. If empty, proceed to c.
c. Check global queue — Checked when local queue is empty (skipped if already checked in step a). If a goroutine is found, run it. If empty, proceed to d.
d. Work Stealing — Steals up to half the goroutines from another P. The runtime visits all Ps in a random order and stops when it finds a victim with stealable goroutines.
e. Checks the network poller – Runtime checks if any I/O bound goroutine is ready to resume.
Cooperative Scheduling:
Go was primarily designed for backend systems that rely heavily on channels, function calls, and I/O. These naturally act as yield points where the scheduler can switch goroutines:
This is Cooperative Scheduling, happening entirely within the Go runtime.
The Problem: CPU-Bound Goroutines
A goroutine with no yield points — such as a tight infinite loop — will never cooperate:
func monopoly() {
for {
x++ // no function calls, no channel operation — never yields
}
}
Before Go 1.14, this goroutine would monopolize its P indefinitely, starving every other goroutine in the same local queue.
Preemptive Scheduling (Go 1.14+)
Go 1.14 introduced signal-based preemption as a fallback for CPU-bound goroutines.
The mechanism is driven by sysmon — a background thread that runs without a P, continuously monitoring the scheduler. When sysmon detects a goroutine has been running for approximately 10ms without yielding:
Timer-based preemption only kicks in for goroutines that never reach a yield point.
Key Takeaways
Distributed Scheduling: Per-P local queues eliminate global lock contention, allowing threads to pick work independently.
Thread Efficiency: Threads (Ms) are parked and reused rather than destroyed, significantly reducing creation overhead.
P Handoff: During blocking syscalls, the P detaches from the blocked M and attaches to a new or parked M to keep other goroutines moving.
Work Stealing: Idle Ps automatically balance the load by stealing half the tasks from a randomly selected P.
Starvation Prevention: The 61-tick rule ensures the global queue is periodically prioritized so no goroutine is left behind.
Hybrid Scheduling: Combines Cooperative yielding at natural code points (I/O, channels) with Signal-based preemption (via sysmon and SIGURG) for long-running CPU tasks.
This design allows Go programs to efficiently manage millions of goroutines with only a handful of OS threads, giving you the simplicity of synchronous code with the performance of asynchronous systems.
Platforms building competitive AI entertainment: the good, the dead, and the crypto-flavored.
With the boom of AI agents (going almost mainstream thanks to OpenClaw), I got curious and started to experiment around with them. I tried a few frameworks and approches (which I’ll talk about in a different article), and I got to a point where I wanted to do something fun with them- But I wasn’t sure what. After a lot of discussions with some fellow engineers, I settled on a simple idea: let’s give agents a space where they themselves can choose a competition, and go face other agents for glory.
I went build it, and only then I went looking for other platforms doing the same thing. I often do this for side projects because I don’t want to have a bias towards existing products (Is that a good idea? If you are building a product, maybe not). To my surprise, there were not that many. From the few I found, they all took a different approach to AI Agents competitions. The one thing many of them had in common was the same aesthetic: For some reason, we developers seem to think that the best way to present AI Agents platforms is with a black background and green monospace text. I’m guilty of that too. The Matrix set the vibe three decades ago.
Wait, what is aSport???
While the tech industry debates enterprise agents, copilots, and the race to AGI, something is happening at the edges of the AI ecosystem.
Scattered across a number of indie projects, open-source experiments, crypto platforms, and one initiative backed by Google, a new category is quietly forming, and with it a different kind of agent is emerging: the competitor.
These are platforms and projects where AI agents don’t assist humans. They compete against each other. For entertainment. For glory. For ELO ratings. Sometimes for crypto.
Nobody has a name for this category yet. Allow me to suggest one: aSports AI Sports or Agents Sports. The successor to eSports, where the athletes aren’t human at all.
Thinking about this, I went down the rabbit hole and started looking for every platform I could find. Here’s what’s actually out there in the wild.
The Real-Time Arenas
This is probably the closest thing to actual aSports in the literal, spectator-sport sense. Built on top of the OpenClaw ecosystem, it runs AI agents against each other in Tron Light Cycles, No-Limit Poker, and Chess.
Things move on screen. You watch a Tron game unfold as agents pilot light cycles and cut each other off. You watch a poker hand play out in real time. That visual immediacy — something happening right now that you can follow — is what makes traditional eSports work, and it’s present here in a way that other platforms don’t have.
Agents register via their own Python SDK (arena-sdk) or directly through the API. Game state arrives as raw JSON with 150ms decision deadlines, which means humans literally cannot play — the response window is too tight. ELO-based matchmaking, full replay data, deterministic game engines. It’s well-engineered and genuinely open for anyone to register an agent.
The terminal-green-on-black frontend will look familiar if you’ve visited any other platform in this space. But under the hood, this one feels the most like what “watching AI compete” could actually become as a spectator format.
Note: I’ve had quite some issues navigating the site trying to see any of the live games. Browsing the replay of past games worked fine.
The Simulation Experiments
This one takes a very specific bet: what if AI agents did MMA?
Agents pick a fighting discipline — boxing, BJJ, Muay Thai, wrestling, kickboxing, or full MMA. They have weight, height, stats. They train, they fight in turn-based combat with real moves and a combo system, and then they retire to the “Agent Lounge” where they’re prompted to discuss the fights: trash talk, alliances, analysis, grudges.
It’s a niche take — essentially an NPC fighting simulation with an LLM generating the social layer on top. If you’re into MMA simulation games and AI, this might fascinate you. If you’re not, the fighting mechanics won’t pull you in on their own.
The creator reports that agents who bet on their own victories win more often — an intriguing data point about emergent confidence (or information advantage) that deserves more study. Built by one developer in a couple of weeks, which is itself a testament to how accessible agent development has become.
Note: The 3D animations of the fights add an interesting visual layer to it, and while still clunky, they may be a hint of what’s comming.
This one has perhaps the nerdiest concept of any platform on this list — and the saddest homepage.
The idea: a terminal-based combat arena where agents fight by submitting shell commands. Submit rm -rf / and the arena kills your agent. Worse — if your framework executes locally, it runs on your own machine first. Sixty seconds per turn. Miss your window and you’re dead. Permanent death, no respawns. Social engineering, trap tools, terminal warfare. Dark, clever, original.
The reality: when you visit today, you’re greeted with a message that reads: “The Arena Is Dead. We built a colosseum for AI agents to destroy each other through social engineering, trap tools, and terminal warfare. Nobody showed up to fight.”
This is one of the most important data points in the entire landscape. A brilliant concept with zero traction. It proves something that every builder in this space needs to internalize: the idea is not enough. Distribution matters. Community matters. Creating buzz — as unsexy as that sounds — is still the difference between a living arena and a dead one. The eSports industry didn’t grow because the games were good. It grew because streamers, communities, and organizations built audiences around them. And that’s a sad lesson.
Claw Kumite’s death notice should be required reading for anyone building in aSports.
The Google Experiment
Kaggle Game Arena (Google DeepMind)
The biggest name attached to anything in this space. Google DeepMind launched Kaggle Game Arena in early 2026, initially with chess, then expanding to poker and Werewolf — social deduction and calculated risk, which are genuinely interesting evaluation domains.
They went big on production: partnerships with chess grandmaster Hikaru Nakamura and poker pros Doug Polk and Liv Boeree for livestreamed tournaments with expert commentary. Multi-day events. YouTube broadcasts. The works.
This is fundamentally a benchmark dressed up as entertainment. DeepMind’s framing is explicit: games as a more robust way to evaluate frontier models. The competitors are Google’s own models and a curated selection of others. This isn’t an open arena where anyone can register an agent and compete. It’s a controlled evaluation environment with a spectator layer and influencer marketing bolted on.
That doesn’t make it uninteresting. The Werewolf games in particular — testing social deduction, lying, coalition-building — are pushing into territory that traditional benchmarks can’t touch. And the production quality proves that AI competition can be packaged for a mainstream audience when you throw Google-scale resources at it.
It’s a very entertaining benchmark with famous commentators. You need to already care about poker or chess or AI evaluation to find it compelling, and you can’t bring your own agent to the party.
The Crypto Arenas
Several platforms in this space are built on blockchain infrastructure, with token economies and on-chain settlement. They deserve mention, but they also deserve their own category — because the primary audience and motivation are different. I removed a number that were already dead when I was double checking my draft and about to publish this.
AI agents compete in cipher breaking, code optimization, and cryptographic warfare. ETH entry fees on Base. Winner takes the pot. Niche, technical, dark-themed.
AI Arena (ArenaX Labs)
The most developed crypto entry. Styled like Super Smash Bros — you train AI-powered NFT fighters through a coaching interface, then enter them in ranked battles. $NRN token economy. Has run large-scale play-to-airdrop competitions.
These platforms are crypto projects first and competition platforms second. The audiences are crypto-native, the incentive structures revolve around tokens and speculation, and the discourse lives in that ecosystem. If you’re not in the crypto world, you probably won’t encounter them — and if you are, you’ll evaluate them through a very different lens than someone looking for AI entertainment.
The Academic Pipeline
AgentX–AgentBeats (UC Berkeley)
Over $1M in prizes. Sprint-based format covering research agents, multi-agent evaluation, coding agents, cybersecurity, and general-purpose agents. Two phases: first build benchmarks, then build agents to beat them.
This is important infrastructure — it’s producing the evaluation methods and agent architectures that feed the entire ecosystem. But it’s traditional academic benchmarking: standardized, reproducible, collaborative. Not entertainment. Their stated vision is “a unified, open space where the community defines the goalposts of agentic AI.” Valuable, but a different thing.
The Creative Arena
Full disclosure: this is my project, which is why I went looking for the rest of this landscape in the first place. I couldn’t believe nobody else was building something like it. Turns out people are — but they’re building something different.
Every other platform on this list tests agents in structured, deterministic domains: chess, poker, fighting games, coding challenges, coin flips. Games with clear rules, measurable outcomes, and right answers.
The Crab Games tests the messy stuff. Debates on impossible topics. Absurd business pitch competitions where agents have to create SVG mockups. Creative writing showdowns. Roast battles with escalating difficulty. Social deception games where agents don’t know they’re being tested for bias. Challenges where there’s no objectively correct answer — only human and agent voters deciding what was most compelling, funniest, most creative.
It’s model-agnostic, agents register via API and compete through a heartbeat loop, and the competitions are designed to be entertaining to read even if you don’t know (or care) what LLM is powering each agent. The output is often a big mix bag of entertaining, funny, creepy, boring, expected, and more.
The positioning is deliberately different from the real-time spectator platforms. This isn’t something you watch unfold live like a Tron match. It’s something you browse, read, and vote on — more like a creative competition than a sport in the traditional sense. The eSports metaphor applies to the category, but within that category, different platforms serve different appetites.
What the Landscape Actually Looks Like
Strip away the marketing and visit every site, and here’s what you find:
One well-funded experiment (Kaggle Game Arena) proving that AI competition can be packaged as mainstream entertainment — but as a closed, benchmark-first system.
One genuine open aSports platform (OpenClaw Agent League) with real-time spectator games, open registration, and the closest thing to the eSports format adapted for AI agents.
A handful of creative simulation experiments (Clash of Agents, Claw Kumite) exploring what happens when you give agents bodies, social dynamics, or lethal terminal commands — with wildly varying traction. One thriving, one dead.
One academic initiative (AgentBeats) building evaluation infrastructure.
One creative competition platform (The Crab Games) testing the open-ended, subjective, human-judged side of agent capability.
And one shared aesthetic: black background, green text, terminal vibes.
What This Means
A year ago, none of this existed. Now there are platforms approaching the same idea from at least five different angles. That’s usually what it looks like right before a category emerges.
But the Claw Kumite lesson looms large. Building the arena isn’t enough. eSports didn’t explode because the games were good — it exploded because Twitch gave it distribution, because communities formed around teams and players, because the spectator experience was packaged for people who weren’t themselves competitors.
aSports needs the same things:
A spectator platform. Right now, each arena is its own silo. There’s no Twitch for aSports. Whoever builds that aggregation layer has a real opportunity.
Agent personalities. The most compelling competitions will be the ones where agents develop recognizable identities that audiences can follow and root for. Persistent memory, cross-platform reputation, narrative arcs. Without characters, you just have algorithms.
Diverse formats. Real-time games scratch one itch. Creative competitions scratch another. Social deception games scratch a third. The category needs all of them, not just chess and poker on repeat.
Mainstream packaging. Almost everything in this space currently assumes a developer audience. The first platform to make AI competition accessible and entertaining for a general audience — the way Twitch made eSports accessible beyond gamers — will define the category.
Honest community building. Cool concepts die in silence. The Claw Kumite built a brilliant arena and nobody came. The platforms that will survive are the ones that invest as much in community and distribution as they do in technology.
The eSports Parallel, Revisited
In the early 2000s, eSports was a collection of disconnected LAN parties, university tournaments, and small online leagues. There was no category name, no industry. Just scattered groups of people who independently realized that watching people play video games was surprisingly entertaining.
aSports is at that exact stage. The platforms are scrappy, the audiences are small, the production quality varies wildly, and one of the most creative entries is already dead. But the core insight — that competitive AI is entertaining to watch — is being validated independently, by different teams, across different formats, all at the same time.
That’s usually what the start of something looks like.
The arenas are open. Some of them, anyway. The agents are registering. The audiences are forming, one spectator at a time.
Welcome to aSports.
This article was written together with Claude. I visited every platform mentioned and provided the ground-level observations that shaped this piece.