posts · 2026-07-27

This piece is worth reading because it digs into the actual multi-agent implementations of Claude Code, OpenAI Codex, Cursor, and Antigravity—not the usual "everyone supports multi-agent now" fluff. Claude Code is experimenting with peer-to-peer Agent Teams, using a shared tasks.md ledger so sub-agents can dynamically claim tasks, with a default cap of 15 concurrent agents. OpenAI Codex takes a pragmatic route: the main node assigns different models and reasoning effort (low/medium/high) per sub-agent based on the task, saving both tokens and time. Cursor binds agent loops directly to IDE state, using Merkle Tree indexing and SQLite for non-blocking background edits—you keep coding while it modifies files. Antigravity is the most governance-heavy: it requires a structured Plan before any code change, waits for your explicit approval via a Proceed Gate, isolates sub-agents with Git Worktree, and logs everything in transcript.jsonl. The selection logic is straightforward: pick Claude Code for complex dependency chains and dynamic coordination, Codex for cost-aware large-scale refactoring, Cursor for seamless in-editor experience, Antigravity for auditable high-stakes systems. I'd discount this a bit—the article is 100% AI-generated and I haven't independently verified the version numbers or config details—but the architectural distinctions it describes are concrete and useful.

This piece is worth reading because it lays out A2A's awkward position clearly. Google built this protocol for a very specific scenario: when Salesforce's AI needs to ask SAP's AI to check financial records, potentially pausing mid-task for human approval. The need is real, but the market is tiny—nothing like MCP, which serves every developer who wants to plug tools into a model. What makes it worse is that inside a single system, local sub-agents in Claude Code and Codex already handle multi-agent work with zero network overhead. Developers dispatch subtasks in memory, no HTTP endpoints or agent cards needed. A2A's irreplaceable value is squeezed into the remaining 10%: cross-company remote RPC. Security is another mess: prompt injection cascades, confused deputy attacks, zombie tasks burning tokens. Google's own Gemini CLI had to patch an A2A isolation vulnerability. My take: it'll quietly exist as enterprise B2B plumbing, but it's going to stay lukewarm among developers. Unless you're building cross-company AI integrations at the Salesforce-SAP scale, you can safely skip this one for now.

This piece is worth reading because it nails down a fuzzy intuition with hard numbers: same Opus 4.7 model, same 105 Kotlin tasks across 8 open-source projects, but Claude Code hit 85.71% and Junie 81.9%. The gap isn't the model—it's how each agent's harness handles Gradle build output. A bad harness dumps hundreds of lines of daemon logs and stack traces straight into the context window. A good one runs Language Server diagnostics first to catch static errors locally, triggers full builds only at checkpoints, and extracts just the blocking lines from the noise. This explains why SWE-bench scores don't transfer to enterprise Kotlin repos. Python lets agents trial-and-error their way to a patch because runtime errors surface eventually. Kotlin's static analysis gives instant feedback at edit time, but every end-to-end verification spins up Gradle daemons, parses KTS scripts, and resolves multi-module dependency graphs—trial-and-error burns tokens and clock time fast. Without a tiered feedback circuit in the harness, even a strong model drowns in build logs. The second half offers a concrete path: stop buying off public leaderboards. Use JetBrains' open-sourced Harbor container spec and Verifier logic as evaluation seeds, then build a private micro-eval matrix from your team's own historical PRs and issues. Measure Pass@k stability, token cost per task, and whether patches respect internal architectural constraints. The Harbor Docker sandbox makes this reproducible rather than aspirational. What's missing: equivalent benchmarks for Java, Swift, and Rust—Kotlin got there first, but the pattern should spread.