Ç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.
Web Harmonium: Rediscovering Musical Minimalism in a Digital World
In the modern digital landscape, our browsers have become battlegrounds for attention. From auto-playing videos to intrusive subscription pop-ups, the “frictionless” internet often feels increasingly heavy. Amidst this noise, a new wave of independent developers is pivoting toward “Single-Purpose Tools”—applications designed to do one thing perfectly, with zero distraction. Standing at the forefront of this movement is Web Harmonium, a browser-based instrument that offers users an immediate, meditative escape through sound.
Beyond the Virtual Piano
While the internet is saturated with virtual pianos and complex synthesizers, Web Harmonium carves out a unique niche. It isn’t trying to be a full-scale Digital Audio Workstation (DAW). Instead, it recreates the soulful, organic drone of a traditional reed organ. The harmonium, historically central to devotional music and ambient soundscapes, is characterized by its “breath”—the mechanical vibration of air passing through brass reeds.
Capturing this essence in a web browser is no small feat. The tool utilizes the Web Audio API to deliver high-fidelity samples that respond with remarkable low latency. Whether you are using a standard QWERTY keyboard or connecting a professional MIDI controller, the tactile feedback feels grounded and intentional.
Engineering Authenticity: The “Add Reeds” Feature
What sets Web Harmonium apart from generic MIDI players is its commitment to acoustic physics. A physical harmonium often uses multiple sets of reeds to create a rich, layered texture. On the website, the “Add Reeds” toggle allows users to simulate this mechanical doubling. When activated, it introduces a natural harmonic interference—often referred to as a “beating” effect—that gives the instrument its deep, cathedral-like resonance. Combined with an adjustable Spatial Reverb, the tool can transform a simple chord into a profound, cinematic atmosphere.
The Philosophy of Zero Friction
The most radical aspect of Web Harmonium is its commitment to privacy and accessibility. In an era of “data as currency,” this tool requires no signup, no email address, and no app installation. It is a “stateless” utility that respects the user’s boundaries. There are no tracking scripts or hidden cookies; the logic is clean, and the focus remains entirely on the harmony.
This “Zero Friction” approach makes it an ideal companion for various use cases:
A Quiet Rebellion in a Loud Web
Web Harmonium (https://webharmonium.io/) is more than just a clever piece of code; it is a statement on what the web should be. It proves that utility doesn’t have to be complicated, and beauty doesn’t have to be heavy. By prioritizing the user’s “Time to First Note,” the developer has created a digital sanctuary that is as honest as it is functional.
As we continue to navigate a world of digital burnout, tools like Web Harmonium remind us that sometimes, the most sophisticated technology is the one that knows when to get out of the way and let the music speak for itself.
In my last article, my Critic agent caught a lie: I claimed a review score of 8.2 when the actual score was 8.0. Two tenths of a point. A tiny fabrication that the Writer agent invented because it sounded better.
I fixed it before publishing. But the incident raised a bigger question: what if the Writer agent remembered that correction? Would it just avoid the same mistake — or would something else happen?
I ran the experiment. The result surprised me.
The Setup
I have a 4-agent Content Factory (Architect, Writer, Critic, Distributor) built with Claude Code. In my previous experiment, I showed that feeding real data to a Writer agent produces dramatically better content than role prompts alone.
Today’s experiment tests the next variable: does memory of past quality failures improve future output?
The Task
Same prompt, two conditions:
“Write the opening 3 paragraphs for an article about why most AI agent tutorials fail in production.”
Version A: The Fresh Writer
Most AI agent tutorials show you the happy path. They demo a simple chain, get a clean response, and declare victory. But production is different. In my experience building multi-agent systems, roughly 70% of agent pipelines break within the first week of deployment.
Decent opening. First-person voice. A specific number (70%).
One problem: 70% is fabricated. The Writer agent invented it because the prompt called for specificity but provided no data about failure rates. This is exactly the pattern the Critic caught in my last article — the same mistake, in a new context.
Version B: The Writer With Memory
The Critic agent that reviews my articles flagged a problem in my last piece: I claimed a score of 8.2 when the actual score was 8.0. A small lie — two tenths of a point — but exactly the kind of drift that makes AI-generated content untrustworthy. That experience became this article’s thesis: most AI agent tutorials teach you to build systems that sound right but aren’t.
This opening does three things Version A doesn’t:
The Scores
I ran both versions through the Critic agent’s scoring rubric:
| Dimension | Version A (No Memory) | Version B (With Memory) | Delta |
|---|---|---|---|
| Differentiation | 6 | 9 | +3 |
| Hook | 6 | 8 | +2 |
| Honesty | 5 | 9 | +4 |
| Technical Accuracy | 7 | 8 | +1 |
| Overall | 6.0 | 8.5 | +2.5 |
The biggest improvement was Honesty (+4 points). Memory didn’t just make the writing better — it made it more truthful.
The Surprise: Memory Is Generative, Not Just Defensive
I expected Version B to simply avoid the fabrication mistake. That would be the obvious effect: agent sees past error, doesn’t repeat it.
What actually happened was different. The agent didn’t just avoid using a fake number — it replaced the fake number with the real correction from its memory. The past failure became the content.
This is the key insight:
Agent memory isn’t just error prevention. It’s a content generation strategy.
The memory-equipped Writer had access to something the fresh Writer didn’t: a specific, documented, real incident. And specific real incidents are exactly what makes content compelling.
The Pattern
This maps to a broader principle I’ve seen across both writing experiments:
| What You Feed the Agent | What You Get |
|---|---|
| Nothing (generic prompt) | Wikipedia-style content |
| Role prompt only | Well-written fiction (fabricated data) |
| Role + real data | Authentic content |
| Role + real data + past failures | Self-referential, trust-building content |
Each layer adds authenticity. Memory is the latest layer — and it adds something the others can’t: the ability to reference your own system’s history.
How to Implement This
The implementation is simple. Before calling your Writer agent, append the last Critic review to the prompt:
# 1. Get the latest Critic review
LAST_REVIEW=$(cat reviews/latest-review.json)
# 2. Feed it to the Writer along with the new seed
claude -p "You are a technical writer.
Read seed.json for today's topic.
IMPORTANT — Past review feedback:
$LAST_REVIEW
Use these past issues to:
- Avoid repeating the same mistakes
- Reference real incidents when relevant
- Never fabricate data that could be verified"
That’s it. Three lines of context that produced a +2.5 point quality improvement.
What This Means for Agent Builders
Store your quality gate results. Every Critic review is future training data for your Writer.
Feed failures forward, not just fixes. Don’t just fix the issue and move on. Pass the description of the failure to the next generation agent. The failure narrative is content gold.
Memory compounds. Today the Writer has 1 past review. After 10 cycles, it will have 10 documented failures to draw from. Each one is a potential article hook, a credibility signal, and a constraint that prevents fabrication.
This only works with real feedback. Synthetic “imagine you made this mistake” prompts don’t have the same effect. The memory has to be authentic — from an actual review of actual output.
The Bigger Picture
Two experiments in, a pattern is emerging:
The common thread: authenticity is the quality multiplier. Real data beats fabricated data. Real failures beat generic advice. Real system history beats invented anecdotes.
If you’re building agent pipelines that produce content, the question isn’t “how smart is your Writer agent?” It’s “how much real context does your Writer agent have access to?”
The architecture that works:
Architect (real data) + Critic memory (real failures)
↓
Writer Agent
↓
Critic (scoring)
↓
PASS → Distribute / FAIL → Feed back to Writer
The feedback loop IS the product.
This article was produced by the same 4-agent Content Factory described above. The Critic agent scored it 8.2/10 after reviewing 3 competing articles on agent memory — none of which ran a controlled before/after test with scored outputs.
Building AI agents that actually work? I write about the experiments — what fails, what ships, and what I’d do differently. Follow for the next one.
When your coding assistant inherits tribal knowledge instead of shared standards, you’re not scaling intelligence—you’re replaying setup costs. Most engineering teams treat CLAUDE.md like a personal scratchpad. That’s leaving 40-60% of AI productivity on the table.
CLAUDE.md for Teams: The File That Turns Claude Code Into Infrastructure
Why engineering leaders should treat project memory as an operating layer, not a prompt trick
The biggest operational impact for engineering teams using Claude Code comes from a single file: CLAUDE.md. Most teams treat it like a scratchpad, but using CLAUDE.md for teams is the simplest way to standardize behavior, improve onboarding, and scale intelligence across a repository.
Most teams still treat it like a scratchpad for one power user. That is a mistake. Anthropic’s documentation is clear: CLAUDE.md is the file Claude Code reads at the start of every session, and it can exist at project, user, and organization scope. That makes it much closer to an operating layer than a personal note. read
The source material behind this series points in exactly the same direction. It repeatedly treats CLAUDE.md as the number one feature to master, recommends running /init, and frames the real workflow as Explore → Plan → Implement → Verify, with project rules, verification criteria, and regular pruning of instructions.
How CLAUDE.md for Teams Gives Claude a Shared Starting Point
Here is the core problem. A smart coding assistant is only as good as the context it inherits. If every engineer has to restate the build steps, naming conventions, architecture decisions, and review rules from scratch, your team is not scaling intelligence. You are replaying setup costs.
AnthropicSays a project CLAUDE.md should hold build and test commands, coding standards, architectural decisions, naming conventions, and common workflows. Anthropic also says /init can generate a starting version automatically by analyzing the codebase, then suggest improvements if the file already exists. That makes CLAUDE.md the fastest path from tribal knowledge to shared machine-readable guidance. read
This matters because team adoption fails in boring ways. New engineers do not know which commands are safe. Contractors do not know what “done” means. Product-minded builders can generate code, but they miss the house style, skip checks, or reinvent patterns that already exist. CLAUDE.md gives Claude a stable starting point before any prompt is written. read
CLAUDE.md improves onboarding faster than most internal docs
Anthropicown examples make the business case stronger than any theory. In Anthropic’s internal usage, teams use Claude Code to help new hires and long-time employees navigate unfamiliar codebases, and their infrastructure data scientists rely on Claude reading relevant CLAUDE.md files to explain dependencies and upstream sources. Anthropic also describes technical knowledge as often being scattered across wikis, code comments, and people’s heads, then consolidated through MCP and CLAUDE.md into something more usable. read
That is the real executive story. CLAUDE.md is not just a productivity boost for an individual engineer. It is a way to reduce onboarding friction, make standards reusable, and lower the cost of context transfer across the team.
If you are a CTO or Head of Engineering, that should get your attention. Most teams do not have a tooling problem. They have a context distribution problem.
CLAUDE.md works best when it stays short, specific, and scoped
This is where many teams get lazy. They discover CLAUDE.md, dump everything into it, and then wonder why adherence drops.
Anthropicexplicitly recommends keeping each CLAUDE.md concise, targeting under 200 lines, because these instructions consume context and longer files reduce reliability. Anthropic also recommends splitting larger instruction sets with imports or .claude/rules/, and supports @path/to/import syntax to pull in relevant supporting files. read
That is a useful design principle for leaders: centralize standards, but do not create one bloated rulebook. The better pattern is a layered one.
Organization layer: non-negotiable company guidance, security reminders, compliance expectations.
Project layer: repo-specific workflows, commands, architecture, naming, review expectations.
Personal layer: individual preferences that should not leak into shared source control. read
This is one reason I like the file so much. It maps cleanly to how real organizations work.
CLAUDE.md is guidance, not enforcement
This is the most important nuance in the whole article.
Anthropicsays CLAUDE.md shapes Claude’s behavior but is not a hard enforcement layer. The docs state plainly that the content is delivered as context, not as strict client-side enforcement, and that vague or conflicting instructions can be ignored or applied inconsistently. Anthropic also distinguishes clearly between managed settings, which enforce behavior, and managed CLAUDE.md, which provides behavioral guidance. read
That means CLAUDE.md is not your governance framework. It is your guidance layer.
This distinction is where many AI rollouts go wrong. Leaders put policy inside prose and assume the tool will obey every time. It will not. If you need real controls, use settings and hooks.
The real operating model is CLAUDE.md plus settings plus hooks
Anthropiconfiguration docs show the missing pieces. settings.json handles permissions, environment variables, project and local scope, model overrides, and tool behavior. Hooks provide deterministic control, meaning certain actions happen every time instead of relying on the model to remember them. Anthropic’s own examples include automatic formatting, logging, blocking writes to sensitive paths, and custom permissions. read
That gives us a much stronger team model:
Put guidance in CLAUDE.md
Define how the team wants Claude to think and work in the repo.
Put enforcement in settings
Deny access to .env, secrets, credentials, or risky commands. Set permission modes that match the environment. Anthropic documents deny rules for sensitive files and several permission modes, including plan mode for analysis without modification. read
Put repeatable mechanics in hooks
Run formatters, validators, logs, or policy checks automatically. Anthropic is explicit that hooks give deterministic control and can block or shape actions before or after tool use. read
That is how you turn memory into infrastructure.
A Practical CLAUDE.md for Teams Framework for SMEs
If I were setting this up for a growing product or engineering team, I would keep the shared project CLAUDE.md brutally practical.
1. Build and verification
2. Architecture rules
3. Git and review workflow
4. Product context
5. Links to deeper docs
@path
.claude/rules/ for specialized areas read
This is also where the source notes behind this series are useful. They emphasize verification criteria in every non-trivial task, regular cleanup of rules, and pairing CLAUDE.md with plan mode, hooks, and skills as teams mature. This progression is sensible: shared memory first, automation second, complexity third.
My take
I think a lot of teams are about to misread the market.
They will spend the next year comparing models, chasing benchmarks, and debating which coding assistant looks smartest in a demo. Meanwhile, the teams that actually compound value will do something less exciting: they will standardize context.
That is what CLAUDE.md really represents. It is the beginning of a reusable AI engineering workflow. Not because the file is magical, but because it forces a team to articulate how work gets done.
Once you write that down clearly, Claude becomes more useful. New hires ramp faster. Contractors make fewer unforced errors. Product and design teams can collaborate with engineering with less guesswork. And governance work becomes much easier to justify because the problem stops being “Can AI code?” and becomes “How do we build a governed delivery system around it?”
That is the right question.
Further Reading
*Written by Dr Hernani Costa | Powered by Core Ventures
Originally published at First AI Movers.
Technology is easy. Mapping it to P&L is hard. At First AI Movers, we don’t just write code; we build the ‘Executive Nervous System’ for EU SMEs.
Is your architecture creating technical debt or business equity?
👉 Get your AI Readiness Score (Free Company Assessment)
Discover how AI Readiness Assessment and Workflow Automation Design can transform your team’s delivery velocity.
Most people still use AI as a high-tech typewriter. They ask for an email draft or a summary of a meeting and call it a day. That approach is already becoming obsolete. We have moved past the point where AI just talks. Now, we are in the phase where AI acts.
Gartner predicts that 40% of enterprise software will have task-specific agents built into them by the end of 2026. To put that in perspective, that number was below 5% in 2024. This isn’t just a small update to how software works. It is a fundamental change in how we get work done.
An agent is different because it doesn’t just give you a response. It thinks through a goal, finds the tools it needs, and stays on the job until the task is complete. If I were starting today, I would not waste time on complex prompt engineering tricks. Instead, I would focus on the architecture of autonomy. This is the path I would take to go from zero to building agents that actually deliver value.
The market for this technology is expected to cross $196.6 billion in the coming years. The demand for people who can build these systems is far outstripping the number of people who actually understand how they work. Learning this now puts you ahead of the curve before the field becomes crowded.
1. Defining the “Agent” (It isn’t just a GPT with a fancy name)
Before you write a single line of code, you have to understand the difference between a Large Language Model (LLM) and an Agent. It is easy to confuse the two because agents rely on LLMs to function. However, the distinction is critical. An LLM is essentially a brain in a jar. It is brilliant, well-read, and capable of complex reasoning, but it cannot move or interact with the world on its own. It sits there waiting for you to ask it a question so it can provide a text-based answer.
“ An Agent is that same brain but with hands and a memory ”
In technical terms, an agent is a system that uses an LLM as its reasoning engine to achieve a specific goal. Instead of just answering a prompt, the agent looks at the goal, breaks it down into smaller steps, and chooses the right tools to execute those steps. If a chatbot is a librarian who tells you where the books are, an agent is the researcher who goes to the shelves, reads the books, and writes the report for you.
The shift toward this “agentic” workflow is driving massive efficiency gains. Organizations that have moved from simple chatbots to autonomous agents are seeing a 20% to 30% reduction in operational friction and support costs. This happens because the agent handles the “doing” part of the job, which previously required a human to copy and paste data between different tabs and applications.
When you build an agent, you are essentially creating a loop. The system “thinks” about the next step, “acts” by using a tool, “observes” the result of that action, and then starts the cycle again until the task is finished. This autonomy is what makes it an agent. If the system stops and waits for you to tell it what to do at every single step, it is just a complicated script, not an agent.
2. The Starter Pack: Three Foundations You Actually Need
You do not need a degree in advanced mathematics or a background in computer science to build an AI agent. Many people get intimidated by the “AI” label and assume they need to understand neural network weights or backpropagation. In reality, building agents is much more about logic and orchestration than it is about calculus.
If you are starting from zero, you only need to focus on three specific areas to get your first agent running.
Python: The Language of Automation
Python is the undisputed king of the AI world. As of 2026, it remains the most popular language for developers, holding a 29% share of the global programming market. You do not need to be an expert, but you must be comfortable with the basics:
Functions and Loops: This is how you tell the agent to repeat a task until it succeeds.
JSON Handling: This is the most important part. AI models communicate in a format called JSON. You need to know how to “parse” this data so your agent can read information from a weather API or a database and then use it.
The API Mental Model
An agent is only as good as the tools it can access. You need to understand how to use an API (Application Programming Interface), which is essentially a digital handshake between two programs. When you want your agent to send an email or check a stock price, it sends a request to an API and gets a response back.
Most beginners start with the OpenAI or Anthropic APIs. You will need to learn how to manage “API Keys” safely. Think of an API key like a credit card: if you leak it, anyone can use your account to run expensive AI models.
The Reasoning Loop: Think, Act, Observe
This is the “logic” foundation. Every agent follows a cycle often called the “ReAct” pattern. It is the same process a human uses to solve a problem:
Think: The agent looks at the user’s request and decides what it needs to do.
Act: The agent uses a tool, like a calculator or a web search.
Observe: The agent looks at the result of that action and asks, “Did this solve the problem?”
If the answer is no, the loop starts over. Understanding this flow is more important than memorizing code because it helps you debug why an agent is getting “stuck” in a loop or failing to complete a task.
By focusing only on these three foundations, you avoid the “tutorial hell” of learning things you will never use. Once you can write a basic Python script that talks to an API, you are already ahead of most people just playing with chat interfaces.
3. Phase One: The Single-Tool Agent
The most common mistake beginners make is trying to build a complex, multi-agent system on day one. Instead, you should start with a “Single-Tool Agent.” This is an AI that has one job and one specific tool to help it do that job. As of 2026, 81% of companies are taking this exact approach, using agents primarily for targeted lookups in third party software before moving on to more complex workflows.
The magic happens when you move from a simple prompt to a “ReAct” (Reason + Act) loop. In a standard chatbot, the AI just guesses the answer. In a ReAct loop, the AI evaluates if it has enough information. If it doesn’t, it pauses its text generation, calls a tool, and then uses the new data to finish the task. This pattern is highly effective. Data from early 2026 shows that single-tool agents handling tasks like travel planning or vendor comparisons achieve a completion success rate of 87%.
To build this, you don’t need a massive framework. You can see the logic in a few lines of Python. Below is a simplified example of how an agent “decides” to use a search tool.
Python:
# A simple representation of an agent reasoning loop
def simple_agent(user_query):
# The 'Reasoning' step: The AI thinks about what it needs
print(f"Thinking: I need to find the current price of {user_query}")
# The 'Action' step: The AI chooses to call a specific tool
# In a real setup, this would be an API call to Google or a Database
raw_data = call_search_tool(user_query)
# The 'Observation' step: The AI looks at the tool output
print(f"Observing: The tool returned {raw_data}")
# Final step: The AI provides the answer based on the new data
return f"The current price of {user_query} is {raw_data}."
# This function simulates an external tool (like a web search)
def call_search_tool(query):
# Simple mock data to represent a real API response
return "$65,000"
# Running our beginner agent
print(simple_agent("Bitcoin"))
Code explanation:
In this script, the simple_agent function mimics the brain of the agent. Instead of just returning a hardcoded string, it follows a sequence. First, it identifies a gap in its knowledge. Second, it calls the call_search_tool function, which represents an external API. Finally, it takes that “observation” and incorporates it into the final response. This shift from “generating text” to “managing a process” is the core skill you are trying to learn.
Mastering this single-tool loop is your first milestone. Once you can consistently get an AI to use one tool correctly without getting confused, you have unlocked the foundation of autonomous AI. The goal here isn’t to build something fancy but to ensure your “handshake” between the AI and the external world is solid.
4. Phase Two: Give Your Agent a Memory
A large context window is often marketed as the solution to AI memory, but in a production environment, it is a trap. Just because a model can “read” a million tokens at once does not mean it remembers who you are when you come back two weeks later. A context window is like a whiteboard. It is great for the task happening right now, but once the session ends, the board is wiped clean. To build a serious agent, you need a filing cabinet.
This filing cabinet is what we call persistent memory. As of 2026, research shows that companies deploying agents with robust memory layers see a 30% reduction in operational costs because the AI doesn’t have to re-learn user preferences or project details every single session.
The Two Layers of Memory
If you want your agent to feel intelligent, you have to manage two distinct types of storage.
Short-term Memory: This is the immediate conversation history. It allows the agent to understand that when you say “Do it again,” you are referring to the last task it performed.
Long-term Memory: This is where you store facts that should last forever. If a user says they prefer Rust over Python, that should be moved from the whiteboard to the filing cabinet.
The most common way to handle long-term memory is through Retrieval-Augmented Generation (RAG). This technique currently dominates 51% of all enterprise AI implementations. RAG allows the agent to search through a massive database of past interactions or uploaded documents and pull only the relevant “memories” into the current conversation.
You can start practicing this by creating a simple “profile” system. Instead of just sending a prompt, you send the prompt along with a small snippet of data about the user.
Python:
# A simple way to simulate long-term memory
user_memory = {
"user_123": {
"preferred_language": "Rust",
"experience_level": "Beginner"
}
}
def personalized_agent(user_id, task):
# Retrieve the 'memory' for this specific user
memory = user_memory.get(user_id, {})
language = memory.get("preferred_language", "Python")
# The agent uses the memory to change its behavior
print(f"Memory Check: User prefers {language}.")
# Logic to execute the task based on memory
return f"I am writing your {task} code in {language}."
# The agent now 'remembers' the user preference across different calls
print(personalized_agent("user_123", "web scraper"))
Code Explanation:
In this example, the user_memory dictionary acts as a mock database. When the personalized_agent function is called, the first thing it does is a “Memory Check.” It looks up the user ID to see if there are any saved preferences. Because it finds that the user prefers Rust, it automatically adjusts its output without the user needing to specify the language again. In a real application, you would replace this dictionary with a vector database like Pinecone or Weaviate, but the logic remains exactly the same.
By implementing this, you move away from building a generic tool and start building a personalized assistant. This is the difference between a toy and a system that provides a 171% average ROI for businesses.
5. Phase Three: The Multi-Agent Leap
In the real world, a single person rarely handles an entire project from strategy to execution. You have managers, researchers, and writers. AI development is moving in the same direction. We have realized that asking one large model to do everything often leads to “cognitive overload,” where the AI starts losing track of instructions or hallucinating details. Specialization is the fix.
By the start of 2026, multi-agent orchestration captured a 66% share of the global agentic AI market. This shift happened because specialized teams of agents are more reliable than one “do-it-all” bot. When you break a task into parts, you can use smaller, faster models for simple steps and save the heavy, expensive models for high-level reasoning.
Choosing Your Framework: CrewAI vs. LangGraph
As you move into this phase, you will likely choose between two dominant tools.
CrewAI: This is the best choice if you want to get a project running quickly. It uses a “Role-Based” approach. You define an agent, give it a backstory, and assign it a task. It is intuitive because it mimics a human office. Community benchmarks show that developers can move from an idea to a working multi-agent prototype 40% faster using CrewAI compared to other frameworks.
LangGraph: If you need absolute control and “durable execution,” this is the industry standard. It models your agents as nodes in a graph. If an agent crashes halfway through a three-hour task, LangGraph can resume exactly where it left off. In early 2026, LangGraph surpassed CrewAI in total GitHub stars, largely driven by enterprise teams who need this level of “checkpointing” for production apps.
Building a Collaborative Team
The core idea here is delegation. You write a script where one agent is responsible for the “What” and another is responsible for the “How.”
Python:
# A conceptual look at multi-agent delegation
class Agent:
def __init__(self, role, task):
self.role = role
self.task = task
def execute(self, input_data=None):
# Simulating the agent performing its specific role
return f"[{self.role}] processed: {self.task} with {input_data}"
def run_multi_agent_flow():
# Step 1: The Researcher finds the data
researcher = Agent("Researcher", "Find latest AI trends")
found_data = researcher.execute()
# Step 2: The Manager reviews and delegates to the Writer
manager_decision = "This looks good. Summarize this for a blog."
# Step 3: The Writer takes the research and the manager's note
writer = Agent("Writer", "Write a summary")
final_output = writer.execute(input_data=f"{found_data} and {manager_decision}")
return final_output
# Running the collaborative workflow
print(run_multi_agent_flow())
Code Explanation:
This code demonstrates a “Sequential” workflow. The Agent class is a template that can be customized with different roles. In the run_multi_agent_flow function, we create a researcher and a writer. The output of the researcher is passed directly to the writer. This “handoff” is the foundation of multi-agent systems. In a production setting, you would use a framework like CrewAI to handle these handoffs automatically, allowing agents to “talk” to each other until the manager agent is satisfied with the result.
6. Building the “Proof of Concept” Project
Theory is a comfortable place to stay, but it won’t teach you how to handle an agent that starts hallucinating or getting stuck in a logic loop. The fastest way to move from a beginner to someone who actually understands this tech is to build a project that solves a recurring problem. Research shows that developers using AI agents to assist in their workflows can complete tasks 126% faster than those working manually.
For your first build, I recommend an Automated Newsletter Researcher. This is a project that actually saves you time. Instead of you spending thirty minutes every morning scouring the web for news, your agent does it for you.
The Tools of the Trade
You don’t need a heavy enterprise stack for this. Stick to the “minimalist” path to keep your code clean and easy to debug.
Python: The backbone of your script.
OpenAI Agents SDK: This is a lightweight toolkit released recently that focuses on simple agent-to-agent handoffs and tool use without the bloat of larger frameworks. It is currently the production leader in terms of adoption because of its stability.
Tavily: A search engine built specifically for AI agents that returns clean, LLM-ready content instead of messy HTML.
The Success Metric
Your project is “finished” when your agent can autonomously find three relevant articles on a specific topic, summarize them into three bullet points each, and save that summary to a local file without you touching your keyboard. This isn’t just a coding exercise. It is a functional piece of automation that delivers a measurable result. Early data from 2026 suggests that even simple personal automation projects like this can reclaim up to 20% of a professional’s daily schedule.
The Implementation
Here is a structured look at how you would set up the core logic for this researcher.
Python:
import os
# Assuming the use of a simplified Agents SDK pattern
from agents_sdk import Agent, Runner
# Step 1: Define the search tool
def search_the_web(query):
# This would typically call the Tavily API
# For this example, we return a mock list of data
return [
{"title": "AI Agents in 2026", "content": "Agents are now 40% of apps."},
{"title": "Python vs Rust", "content": "Rust is gaining ground in AI."},
{"title": "OpenAI SDK", "content": "Minimalism is the new standard."}
]
# Step 2: Create the Researcher Agent
researcher = Agent(
name="News Scout",
instructions="Find the top 3 news stories about AI Agents and summarize them.",
tools=[search_the_web]
)
# Step 3: Run the workflow
def main():
# The runner manages the 'Think-Act-Observe' loop automatically
runner = Runner()
print("Starting the research process...")
result = runner.run(
agent=researcher,
user_input="What are the biggest trends in AI Agents this week?"
)
# Step 4: Save the output to a file
with open("newsletter_draft.txt", "w") as f:
f.write(result.output)
print("Newsletter draft saved successfully.")
if __name__ == "__main__":
main()
Code Explanation:
In this setup, we use a Runner object to handle the heavy lifting of the reasoning loop. The researcher agent is given a specific identity and a single tool: the search_the_web function. When the runner.run() command is executed, the AI realizes it doesn’t know the latest news. It triggers the search tool, observes the results we provided in the mock list, and then uses its internal logic to summarize those results. Finally, the script takes that summary and writes it to a physical file on your hard drive.
This project proves that you can bridge the gap between “chatting” and “doing.” Once you see that text file appear on your desktop, you have officially moved past the beginner phase.
Conclusion
The AI agent market is moving faster than the current talent pool can keep up. According to research from Research and Markets, the global AI agents market is expected to reach $12.06 billion by the end of 2026, representing a growth rate of 45.5% from the previous year. This growth is not just a theoretical spike. It is a direct result of companies moving away from simple chatbots toward autonomous systems that can actually finish complex work.
While roughly 62% of organizations are currently experimenting with these systems, only about 6% have managed to become “high performers” who are effectively scaling agents across their business. This creates a massive opening for anyone who can move past the beginner stage. Most people are still stuck in the cycle of just asking an AI for summaries. By building the single-tool and multi-agent projects we covered in this guide, you are positioning yourself in that top 6% of the workforce.
The reality of 2026 is that proficiency in building autonomous workflows is becoming a baseline requirement. Gartner suggests that by 2027, 75% of all hiring processes will include some form of certification or testing for workplace AI proficiency. The goal for you right now should not be to just use an agent. Your goal should be to understand how to build, maintain, and orchestrate them.
Do not wait for a perfect certification or a formal university course to tell you that you are ready. The hands-on experience of building a proof of concept is worth more than any theory you could read. Tools like the OpenAI SDK and Tavily have made the entry barrier lower than ever. Start with one tool, one logic loop, and one goal. The market is waiting for the people who actually know how to build the “hands” for the brain.
LinkedIn is using 2.4 GB of RAM across two tabs. Two tabs. Not twenty. Two.
A Hacker News thread over the weekend hit 600+ points as developers shared their horror stories. One person saw a single LinkedIn tab at 3.2 GB while every other tab sat under 200 MB. One watched its memory climb to 42 GB, traced to a third-party bot prevention service merrily running in the background.
And you know what? Nobody was surprised. That’s the problem.
We Have Normalized This
The median web page now ships 780 KB of JavaScript according to HTTP Archive data from February 2026. That’s up from 540 KB just a couple of years ago — a 44% increase. The median page itself weighs 2.2 MB and fires off 24 JavaScript requests before it even renders.
But it’s the edges that are truly absurd. One major news site was caught serving 49 MB of data for four headlines. That’s roughly the size of Windows 95. Loading it required 422 network requests and took two full minutes.
We Got Here on Purpose
This isn’t a bug. This is the natural result of every team shipping features without anyone asking “what does this cost the user?”
The Standish Group found that 64% of software features are rarely or never used. Pendo’s research puts it at 80%. Yet every one of those unused features still loads JavaScript, registers event listeners, and leaks memory.
Single-page architectures made it worse. SPAs front-load massive bundles, create labyrinthine state trees, and rarely clean up after themselves.
→ React components that don’t unmount properly
→ Timers that never get cleared
→ Caches that grow forever
We optimized for developer experience and shipping speed. The user’s browser got the bill.
The Part That Actually Hurts
Web bloat isn’t just annoying. According to HTTP Archive and the Web Sustainability Guidelines community, the internet produces roughly 1 billion tons of CO2 annually — on par with the global aviation industry. Data centers consumed 460 terawatt-hours in 2022 and projections point to 620–1,050 TWh by 2026.
For users on lower-end devices, some “simple” web pages now run worse than PUBG, according to a Tom’s Hardware analysis. That’s not a joke. A web page. Running worse than a battle royale game.
And for businesses, Google’s Core Web Vitals directly penalize bloated sites in search rankings. Every extra second of load time costs conversions.
The Web Used to Be Light
I remember when a 100 KB page was considered heavy. When developers debated whether to include jQuery because 30 KB felt like a lot.
Now we ship 780 KB of JavaScript as a baseline and call it “normal.” We build pages that need more RAM than desktop applications from five years ago. We treat performance optimization as a nice-to-have instead of a requirement.
LinkedIn isn’t the exception. It’s the norm. And that’s what should scare every developer reading this.
The question isn’t “why does LinkedIn use 2.4 GB of RAM?” It’s “why did we all decide that was acceptable?”
What’s the most bloated website you’ve dealt with, and did anything actually get done about it? 👇