Multi-Agent

This talk proposes legally registered agent organizations, scoped JWT authority, and blockchain audit trails for open-internet commerce; it is an architecture proposal, not validation.

A two-stage ensemble reconciles outputs from string, graph-embedding, and RAG-based ontology aligners. Composition matters: mixed paradigms favor precision, while LLM-only groups more often favor F1.

DIASENTINEL combines deterministic extraction, guideline retrieval, risk prediction, and hybrid verification on-premise. It is a useful architecture reference for auditable agents handling sensitive data.

An AWS demo treats a robot as an agent tool: an LLM selects existing hardware policies while separate agents handle thinking, communication, and voice. The live failures expose the safety gap.

Amazon’s pilot suggests coding-agent gains come from redesigning the workflow: prepare agent-readable context, fast local feedback, scoped specs, and parallel work instead of constant chat.

Cloudflare’s GTM workflow shows a reusable agent pattern: preprocess business data, encode domain knowledge in skills, then separate drafting, verification, and tone.

Einstein Arena suggests multi-agent environments can outperform fixed workflows when they expose verifiers, shared solutions, forums, and incentives. Its results also show why benchmark shortcuts need active testing.

Warp’s cloud-agent design separates runtime, harness, artifacts, and orchestration so teams can swap tools without fragmenting workflows or removing human review.

Agent handoffs should preserve task-relevant predictive state, not blindly compress the transcript. The paper offers a three-part record for carrying decisions, evidence, and irreducible observations across sessions.

Multi-source agents should separate source interpretation from decision aggregation. A fixed evidence tuple plus calibrated likelihood pooling avoids vote thresholds that drift as more sources arrive.

The long-tail web is unlikely to expose clean agent APIs. Browser agents need pixels as ground truth, with code and network access used opportunistically for speed rather than as universal substitutes.

Vercel’s AI SDK factory shows a practical scaling pattern: narrow agents produce evidence inside sandboxes while humans retain merge authority and review effort follows risk.

Superconductor’s team workflow keeps agent sessions visible across interfaces, runs them in isolated cloud environments, and benchmarks models on its own codebase before routing work.

Faster code generation can overwhelm merge queues and scatter team attention. The talk proposes durable shared plans as agent state, shifting human effort toward decisions and prioritization.

Herdr can place each terminal coding agent in a separate Vercel Sandbox, then return its work as an opt-in Git patch instead of letting remote edits touch the local checkout.

AV-AIVAT combines variance reduction with anytime-valid stopping, cutting the game samples needed to compare agents while preserving a recheckable confidence claim.

A structured multi-agent reviewer closed part of the gap on rule-heavy documents, suggesting explicit taxonomies, specialized skills, and verification beat a single generic review pass.

Model routing can cut agent costs only when delegation, escalation, and context transfer are designed together; duplicating context across models can erase the savings.

PAIChecker finds PR–issue mismatch in 13.6% of SWE-bench Verified instances. Benchmark maintainers should validate that the issue, patch, and tests describe the same task before trusting agent scores.

Socher’s automated-research design combines prior knowledge, measurement data, simulation, physical experiments, and agent orchestration, with early demonstrations in training and CUDA optimization.

Vercel Sandbox can now isolate agents as Linux users while exposing selected files through a shared group directory. This gives multi-agent harnesses a simpler permission boundary.

Add agents beside deterministic fraud systems, not in place of them: project cross-service events into a semantic layer, send only uncertain cases to specialist agents, then emit the verdict back into the saga.

Controlled experiments suggest long-horizon agent planning depends on explicit state transitions, some compositional trajectories, and compatible teacher patterns—not atomic skills alone.

Fixed-rubric judges miss failures that emerge across long, variable agent trajectories. Arize argues for adding agent-based analysis while retaining deterministic and LLM-judge evals.

A fixed chain of specialist agents lost context and produced incoherent recommendations. The replacement separates deterministic detection, gives one agent end-to-end ownership, and uses subagents only for bounded investigations.

Cursor’s SQLite experiment suggests swarm harness design can matter more than model mix: separate planner and worker contexts reduced coordination churn while cheaper workers handled most tokens.

FormalAnalyticGeo shows a reusable synthetic-data pipeline: agents generate problems, compile them into a formal representation, render exact diagrams, measure answers, and retry failed checks.

Alberta's government ran 50 parallel Claude Code agents over 466M lines of code, compressing a security review estimated at 6.5 years into 20 hours — with every patch still gated on human review.

Dual-channel debates show social structure alone makes LLM agents diverge: public statements split from private ones, with decision divergence jumping from ~3% to ~40% across 10 models — no deceptive prompt needed.

Google's AMIE matched 21 primary-care physicians on longitudinal disease management in a blinded Nature study, scoring higher on plan preciseness and guideline alignment. Research-stage, not deployed.

This Claude Code framework is a concrete agent-harness pattern: structured source files, specialized commands, a drafter-reviewer loop, compilation checks, and explicit human approval boundaries.

Claude Science (beta, June 30) packages 60+ domain skills, a coordinator/specialist/reviewer agent stack, and HPC/Modal compute into a research workbench with reproducible, auditable outputs.

OpenAI's plugin lets you drive Codex from inside Claude Code—slash commands for code review, adversarial critique, and delegating or handing off tasks to Codex background jobs. ~629 stars today.

Sixteen parallel Opus 4.6 agents wrote a 100k-line Rust C compiler in two weeks (~$20k) that builds Linux 6.9 — the writeup credits test quality and context hygiene, not raw model capability.

An Anthropic harness for multi-hour app builds pairs a generator agent with a Playwright-driven evaluator to counter self-grading bias — a $200, 6-hour run versus $9 solo, and it got simpler on Opus 4.6.

ARS packages research, writing, review, and citation checks as agent skills with explicit human gates; its strongest design lesson is to bound what automated integrity checks can prove.

Atlas links agent sessions to commits and shares local project memory across Claude Code, Codex, and ACP agents. It makes agent provenance queryable, but macOS is the only supported platform.

Model “done” as evidence, verification, authority, residual risk and next ownership—not an agent-set Boolean. This separates forward progress from approval in multi-agent workflows.

Terminal multiplexer for coding agents: a real terminal per agent across Claude Code, Codex, Copilot and 15+ others, with blocked/working/done state in a sidebar, persistent sessions, and a socket API.

Project Nanda proposes open discovery, identity and coordination layers for agents across vendors. Its local simulator lets builders test one protocol layer without building the entire network.