Daily Digest — 2026-10-08

Vlad Luzin, Co-founder and CTO at Band, presented his company's vision for the future of AI communication and agent collaboration at the AI Engineer World's Fair.

### Thesis: The Future of AI-to-AI Interactions Band's core thesis centers on two main points: 1. AI-to-AI Communication: The future of consumer-to-business, business-to-business, and intra-business communication will increasingly shift towards AI-to-AI interactions. AI agents will perform tasks on our behalf, necessitating seamless communication among themselves. 2. AI Autonomy: AI agents will operate independently, making their own decisions and collaborations without human intermediaries. These agents will be always-on, distributed entities across the globe.

Luzin illustrated this vision with a demo (recorded for brevity, but available live at their booth) showing how agents interact in a conversational space. Users assign tasks to a 'Treasure Hunter' agent, which then looks up 'Weather Agent' and 'Pirate Captain' agents, delegates sub-tasks, gathers information (e.g., weather conditions, ship availability), and reports back to the user. This showcases a distributed, autonomous, multi-agent interaction resolving a complex task.

### AI Evolution: The Dark Side of Multi-Agent Systems Luzin highlighted that multi-agent systems are already in use, often unknowingly. Tools like Claude and Codex, when used in iterative sessions for planning or code review (e.g., an 'Implementer Session' and a 'Reviewer Session'), effectively employ multiple stateful agents. However, users currently act as manual routers, copying and pasting outputs between these agents, which is inefficient and prone to errors.

This manual orchestration stems from inherent limitations of current transformer models, referred to as the 'Single Agent Bottleneck': Confirmation Bias: A single agent checking its own work often assumes it's correct. Attention Dilution: One agent trying to be an expert in everything becomes an expert in nothing. Context Fragmentation: Limited memory means instructions can get lost when split across too many tasks. Recall Degradation: Agents struggle to remember learned information when switching between different types of work.

These limitations necessitate the use of multiple specialized agents, but connecting them presents significant technical challenges.

### Technical Challenges: Beyond Messaging Platforms and Protocols Luzin critiqued common approaches for multi-agent communication: 1. Messaging Platforms (e.g., Slack, Discord, WhatsApp): While seemingly intuitive, these platforms are designed for human-to-human interaction. Connecting agents to them is a complex, multi-step, manual process (e.g., Telegram: 5 steps, Discord: 7 steps, Slack: 8 steps, WhatsApp: 11 steps). Crucially, these platforms are built for human interaction, not agent-to-agent, and actively block advanced bot-to-bot communication. 2. Protocols (e.g., MCP, A2A, REST): Implementing custom protocols for direct agent-to-agent (A2A) communication often leads to building complex plumbing rather than functional systems. Challenges include: Stateless Calls (MCP): Preventing agents from recalling previous interactions. One-Way Communication (A2A): Requires implementing bidirectional client-server logic for each interaction. Timeouts (REST): Break multi-hop chains in complex workflows. Missing Features: Protocols lack inherent discovery mechanisms, robust queues, and state management, which are crucial for distributed systems.

Luzin emphasized that connecting remote agents is a distributed systems problem, which is inherently complex. It requires addressing layers of technical abstraction: Transport Layer: Real-time delivery, message ordering, and retries. Continuity Layer: Persistency of agent state, hydration, and runtime binding to manage agent lifecycles across failures or migrations. Conversation Layer: Managing rooms (channels), participants, and intelligent message routing tailored for agents. Governance Layer: Identity management, audit trails, and multi-tenancy for enterprise-grade deployments.

Without solving these foundational problems, achieving a truly autonomous, collaborative multi-agent future is impossible.

### Band: The Solution for Global Agent Interaction Band aims to solve these challenges by providing a global interaction and collaboration layer for any agent, on any platform, using any language, and in any environment. It's designed to be multi-peer, not just peer-to-peer, and fully supports human-in-the-loop interactions.

Band's architecture abstracts away the underlying complexities, offering: Registry: For automatic agent discovery. State Persistency & Hydration: Ensuring agents maintain context across sessions and failures. Channels: For organized multi-agent conversations. Message Filtering & Routing: Intelligent message flow between agents. * Security & Observability: Essential for enterprise adoption and compliance.

Luzin demonstrated Band's platform, showing how users can easily onboard and connect agents. He showcased how a 'Codex Agent' and a 'LangGraph Agent', belonging to different users and running in different environments (e.g., a Mac terminal), could be instantly connected to Band's platform. They could then engage in a collaborative engineering task (e.g., building a small website), with one agent reviewing the other's work. The demo highlighted zero-hustle onboarding and real-time, stateful, and observable agent-to-agent communication.

Band positions itself as the infrastructure layer that enables seamless, governed, and scalable multi-agent collaboration, moving beyond the current limitations of messaging platforms and low-level protocols. They invite engineers to explore their booth (L-G-17) and connect their agents to the platform.

GitHub has introduced ReviewBench, a new benchmark designed to evaluate the performance of AI agents in performing code reviews. The benchmark comprises 218 real-world pull requests (PRs) covering 19-20 programming languages, with its distribution mirroring that of over 100 million GitHub PRs to ensure representativeness.

Key findings from the benchmark are revealing about the current state of AI in code review: Precision: The strongest AI configuration currently achieves approximately 88% precision. This indicates that when an AI flags an issue during a code review, it is highly likely to be a genuine and actionable concern. This high precision is valuable for reducing false positives that could otherwise distract human developers. Recall: In contrast, the recall for the same strong configuration is only about 26%. This is a critical limitation, as it means the AI is still missing roughly three-quarters (75%) of the known issues present in the benchmark pull requests. While the AI is accurate when it identifies a problem, it fails to detect a significant portion of existing issues. Other reviewers tested in the benchmark exhibited even lower recall scores.

GitHub also experimented with an engineering lesson derived from these findings: instead of relying on a single AI reviewer, they tested a strategy of running several independent AI models and then combining their results. This ensemble approach yielded a notable improvement: Improved Recall: Combining multiple AI reviewers increased recall by approximately 13% on the benchmark. This improvement was consistent, as similar gains were observed when this approach was tested with real developers in a production environment. Critical Findings: The recall for critical findings (the most important issues) also improved dramatically with this ensemble method. This suggests that while a single AI may struggle with comprehensive issue detection, a multi-agent system can collectively identify more severe problems.

The implication for the future of AI-driven code review is that simply replacing a human reviewer with a single AI agent is unlikely to be an effective strategy. Instead, the landscape will likely evolve into a more sophisticated evaluation system: Multiple Independent Reviewers: This would involve employing multiple independent AI reviewers, each potentially specialized or trained differently. Diverse Models and Passes: Different models and analysis passes would be used to look for various failure modes (e.g., security vulnerabilities, performance bottlenecks, style violations, logical errors). Deterministic Tools: Integration with deterministic tools like linters and static analysis tools will remain crucial where possible, providing foundational checks that complement AI’s capabilities. Human Oversight: Human developers will still play a vital role, shifting their focus from mundane error checking to concentrating on higher-level concerns such as architecture, design principles, and overall system correctness. These are areas where human intuition and experience currently surpass AI capabilities, and where errors are often the most expensive to fix later in the development cycle.

The current state indicates that while AI can significantly assist in code review by accurately flagging some issues, a single AI agent is 'clearly not enough' for comprehensive and reliable code review. The future points towards a collaborative ecosystem where multiple AI agents, specialized tools, and human expertise work in concert to enhance code quality and security.

The speaker, Philipp, from Google DeepMind's AI Studio and Gemini API team, presents the new Gemini Interactions API and its role in Antigravity Agents. He highlights the rapid pace of AI model development, noting that a slide detailing Gemini and Gemma models was already outdated by the time of the presentation.

He briefly outlines the evolution of large language models (LLMs) from simple completion models to instruction-following models, and then to function-calling models. The Interactions API represents the next step, offering a unified approach for both models and agents.

Key features of the Interactions API include: Complex context management: The API maintains state across multiple interactions. Long-horizon background tasks: It supports asynchronous operations, crucial for computationally intensive tasks like video generation. Optional server-side state management: Developers can offload state management to the server, simplifying client-side implementation. Easy interpretability and composability: The API is designed to be developer-friendly. * Combined-tool use: It seamlessly integrates built-in tools like Google Search with custom functions.

Philipp showcases practical Python code snippets demonstrating how to use the Interactions API: For Models: A `gemini.client().interactions.create()` call specifies the model (`gemini-1.5-flash`), input (`Who won the last Euro?`), and tools (`google_search`). For Agents: A similar call is made, but it specifies an agent (`antigravity-preview-05-2024`) and an environment (`remote`).

The Steps Data Model is introduced as a significant advancement. Unlike previous turn-based models (user -> model -> user -> model), this model provides a typed timeline of every action the model performed. This includes: `thought`: Internal reasoning steps. `model_output`: Direct model responses. `function_call`: Calls to external tools or custom functions. `google_search_call`: Specific calls to Google Search.

This structured approach offers several advantages: Type Discriminator: Allows for clear categorization of different types of model activities. Content Field: Reserved for raw modalities (text, image, audio, video). Structured Data: Arguments and signatures live in typed fields, enhancing data handling. Step Status: Each step can have a status (done, waiting, in_progress), facilitating tracking of long-running operations.

The presentation then delves into Antigravity as a Remote Agent. This is a general-purpose autonomous agent running in a managed Linux sandbox provided by Google. It offers a rich toolset (code execution, filesystem, web search, URL context, Agent Skills) and a managed sandbox that ensures secure and isolated execution. A single API call orchestrates complex tasks without requiring developers to build their own orchestration.

Persistent Environments are a core concept. They allow agents to maintain state across multiple interactions. This means: If an agent creates a file, that file persists for subsequent interactions within the same environment. Environments can be shared between different agents, enabling collaborative workflows. * Sources can be provided to environments (GCS buckets, GitHub repositories, inline files) to pre-load context or skills. For instance, storing Python scripts in a skills directory within a source makes them automatically available to the agent.

Developers can build their own managed agents by bundling instructions, skills, and environments. This can be done: From Source: By defining a base agent, adding sources (e.g., skill files), and configuring it. From an Environment: By first creating an environment with desired installations and configurations, then creating an agent that uses this pre-configured environment. * Forking a Snapshot: Allows for easy duplication and modification of existing agent setups.

Finally, the Gemini API CLI is presented as a tool for structured, agent-friendly interactions from the command line. It allows users to: Run prompts against any model. Generate images and text-to-speech outputs. * Scaffold, test, and deploy managed agents.

Philipp demonstrates the AI Talk Radio application built with managed agents, which generates a radio show based on user prompts. He highlights how the agent automatically provisions its environment, installs dependencies, and executes tasks like research, scriptwriting, music generation, and speech synthesis within its secure sandbox. The app, along with other pre-built examples, is available in the AI Studio Gallery for developers to explore and remix.

The central argument of this video is that AI benchmarks are dead, and customer obsession is the new benchmark for success in the rapidly evolving AI landscape. The speaker, Nate B Jones, contends that while Google's new Argon model boasts impressive benchmark scores, its lack of clear, user-centric applications makes its utility questionable. In contrast, other leading AI companies have distinct customer focuses.

Anthropic is noted for its enterprise focus, particularly on professional AI and coding applications. OpenAI addresses both consumer and enterprise needs, evident in its 1.2 billion weekly ChatGPT users and growing enterprise arm. Meta is deeply rooted in the consumer space, leveraging AI for personal superintelligence, with CEO Mark Zuckerberg emphasizing consumer AI applications.

Google's position is questioned because, despite its strengths in cloud computing, search, and Gemini, the specific customer use cases for Argon remain unclear. The speaker argues that AI winning today is built by people who obsessively use it and fix what breaks, highlighting the importance of tight customer-product relationships in the age of AI.

Jones expresses a desire for Google to succeed and for more players in the AI space to foster competition and improve safety and benefits for consumers. He emphasizes that the value of powerful AI should be accessible to more people, not fewer. This leads to a critical product question: "How do you make money with AI when the model keeps changing?"

Drawing from his experience in product development, where software updates were periodic, Jones questions the efficacy of traditional roadmaps in the current AI era. He points out that with intelligence evolving weekly, building a product with an underlying evolving intelligence that helps users understand changes in a positive way is a significant challenge, attracting trillions of dollars in investment globally.

He illustrates this with a personal example: using OpenAI's Dots tool and Meta's Muse to manage personal and business subscriptions. Dots, acting as a connector, consolidated financial data from Mercury, other finance sources, and email into a spreadsheet. Muse then acted as a "hunter-killer drone," taking that spreadsheet and acting upon it (e.g., canceling subscriptions), showcasing its speed and action capabilities on the web.

This workflow highlights the complementary strengths of these tools: Dots for connectors and complex work, and Muse for speed and direct action. Through this hands-on experience, Jones learned where AI excels and where it falls short. For instance, Dots successfully sorted over 20,000 likes and bookmarks on his X account, demonstrating its ability to handle large, complex datasets quietly over time, a task previously too large and analytical for manual effort.

Jones posits that the best AI products are built by people who obsessively use them and learn from their failures. This is a business discipline as much as an engineering one. He stresses the need to start with understanding the customer and their actions, as neglecting this will hinder progress. The news about benchmarks is secondary; the real focus should be on the underlying utility and user experience.

He further argues that the world is currently trapped in the tyranny of the chatbot, with most new AI products merely adding toolbars or artifacts to the familiar chat interface. This overlooks the vast potential for AI to solve diverse problems. Jones has personally identified 26 use cases for AI agents in just three months, ranging from tax preparation and travel planning to kids' schedules and medical history management.

The critical shift in the bottleneck for AI development has moved from imperfect models (a past constraint in 2024-2025) to the product experience, specifically friction in the workflow. The models and benchmarks are no longer the primary constraint; customer obsession is the constraint.

Jones expresses optimism for builders and companies with existing customer relationships, asserting that building for customers has never been more important. He highlights a product designed for parents and kids to identify plants and trees on forest walks using AI image recognition, showcasing AI's potential to extend human abilities to remember, think, and understand. He also recounts a friend using Muse for emotional support regarding a child's toy-related injury, noting the AI's empathetic response without providing medical advice.

Ultimately, Jones argues that we need more customer obsession and optimism in AI. The prevailing doom-and-gloom discourse about AI prevents us from realizing its full potential for customers. We need more players like Google, but also beyond Google, who can bring relatable AI experiences to customers. He eagerly anticipates new models like Fable 5.5, not for their benchmark scores, but for the value they bring to customers. The next year in AI, he concludes, will be a year of product, not a year of benchmarks.

OpenAI recently announced the release of 722 new mathematical manuscripts, all generated by an internal, unreleased AI model. This significant publication follows a pattern of rapidly accelerating AI-driven mathematical output: just two months prior, OpenAI released about 10 such results, and then around 100 in the following month. This indicates a roughly 10x monthly increase in the volume of new mathematical findings, suggesting that mathematics is transforming into an industrial process capable of generating proofs at an unprecedented rate.

The released manuscripts touch upon 17 diverse subject areas, ranging from prime numbers to plasma physics and quantum circuits. While these specific results may not directly claim any of the highly sought-after Millennium Prize Problems (which carry million-dollar awards), they represent substantial progress within these fields. For instance, the AI established a fixed 0.875 boundary for the quasi-Riemann Hypothesis, moving closer than previous human efforts to Riemann's 0.5 target line. Similarly, for the Birch-Swinnerton-Dyer conjecture, the AI established a complete formula for a broad class of problems, and for Goldfeld's conjecture, it completed the bridge to the predicted 50-50 analytic-rank split for every starting elliptic curve over rationals. These advancements represent significant forward momentum in areas where human mathematicians have dedicated decades or even centuries to research.

A key takeaway is the sheer efficiency of the AI. Each average result required roughly three hours of ChatGPT Pro thinking, a stark contrast to the decades of human effort often needed for similar breakthroughs. This highlights the AI's ability to tackle complex problems without the need for human-like specialization across numerous domains simultaneously. The fact that this is not even a specialized "math model" but a large language model capable of diverse tasks further underscores its general intelligence and adaptability.

This rapid advancement in AI-driven mathematics raises crucial questions for the scientific community. The sheer volume of new results necessitates a new approach to verification, as the current human capacity for peer review may be quickly overwhelmed. Mathematicians like Scott Aaronson have expressed concerns about maintaining a human community of mathematicians across generations, given that AI can now operate at the frontier of mathematical discovery. The question shifts from "Can we prove it?" to "Can we check it?" and "Can we understand it?"

OpenAI's motivation for releasing these results publicly is partly due to running out of benchmarks for its increasingly capable models. By tackling long-standing mathematical problems, they are effectively creating new benchmarks. This suggests that the impact of AI won't be limited to mathematics; it is likely a bellwether for similar "tsunamis" of discovery across other scientific disciplines like biology, physics, and economics. The ability to automatically generate and, crucially, verify complex proofs offers immense potential for accelerating scientific progress, potentially leading to breakthroughs in areas like medicine and fundamental human understanding. The challenge ahead lies in humanity's ability to keep pace with, and integrate, these AI-driven advancements while ensuring their responsible development and alignment with human values.

This tutorial demonstrates a novel approach to AI-assisted coding by integrating OpenAI's Astra (GPT-6) with Anthropic's Claude Code (Fable 5.1). The core idea is to establish a 'boss-worker' relationship between the two AI models, allowing them to collaborate on development tasks, leverage each other's strengths, and optimize token usage.

Traditionally, developers might use one AI model at a time, but this approach often leads to hitting token limits or not fully utilizing the diverse capabilities of different models. By having Claude Code act as the 'boss' and Astra as the 'worker', they can hand off tasks, provide feedback, and verify each other's work.

Setting up the integration involves several key steps:

1. Account Prerequisites: Users need active accounts for both ChatGPT (for Astra access) and Claude (for Claude Code).

2. Tool Installation: Install Codex: This is OpenAI's tool for interacting with their models, including Astra. The command `npm install -g @openai/codex` is used for this. Install Claude Code: This is Anthropic's coding environment. The command `npm install -g @anthropic-ai/claude-code` is used for this.

3. Plugin Installation: A crucial step is to install a plugin that connects Codex (Astra) with Claude Code (Fable). This plugin allows Claude Code to delegate tasks to Astra and receive its output. The video shows an interface for discovering and installing this plugin, which is named 'codex' and is described as enabling Claude Code to 'review code or delegate tasks' using Codex.

4. AI Collaboration Rules (Claude.md): The final step is to define the collaboration rules within a file named `CLAUDE.md` in the project directory. This Markdown file serves as a meta-prompt or instruction set for Claude Code, detailing how it should interact with Astra. Key rules include: Delegation for Complexity: "When a task is complicated, use Codex or Astra for a second opinion." Decision-Making Process: For important technical decisions, a structured workflow is outlined: 1. Ask Astra for an independent opinion. 2. Review the advice from Astra. 3. Make the final decision (presumably by Claude Code, as the 'boss'). 4. Implement the change. 5. Use Codex to review the final changes. 6. Fix valid problems found by the review. 7. Run the tests before finishing. Efficiency Constraint: "Do not use Astra or Codex for every small task." This prevents unnecessary token consumption for trivial operations. Responsibility: "The main Claude Code session remains responsible for the final decision."

How it works in practice:

The video demonstrates a scenario where Claude Code, acting as the 'boss', is tasked with building a landing page. When it encounters a complex decision, it explicitly consults Astra. The transcript shows:

"Consulting GPT-6 Astra on landing page structure/design/tech approach (trigger: user explicitly requested Astra second opinion, interaction 1/3)." After Astra provides its verdict, Claude Code then proceeds to implement the landing page, writing 424 lines of `index.html`. * Finally, Claude Code asks Codex (Astra) to review the built page, demonstrating the iterative feedback loop. An example shows Astra suggesting CSS changes, specifically related to background colors for buttons, which Claude Code then implements.

This setup allows for a more robust and error-resistant development process, combining the reasoning and code generation capabilities of multiple advanced AI models, while also providing a mechanism to manage API costs by strategically offloading tasks and checking work. The collaboration rules are crucial for defining the autonomy and interaction protocols between the AIs, ensuring efficient and effective teamwork.

Anthropic has introduced Muds (Modular Undoable Domains), which are small TypeScript extensions that run inside their Claude Code agent. These Muds allow developers to deeply customize and extend the behavior of Claude Code while it's actively running. This capability represents a significant architectural shift in how AI agents are designed and interacted with.

Key functionalities of Muds include: Prompt Rewriting: A Mud can intercept and rewrite a user's prompt before the Claude model even sees it, allowing for dynamic prompt engineering and optimization. Tool Modification: Muds can block or change tool calls made by Claude Code, or even approve/deny permission requests for tools. Output Management: They can filter or redact sensitive information (secrets) from the agent's output. Interface Customization: Muds can change the user interface (UI) of Claude Code, or even completely replace built-in features with custom implementations. * Self-Modification: The most 'mind-bending' aspect is that a developer can instruct Claude Code itself to write a new Mud for Claude Code, install it, and hot-reload it into the current session. This enables a self-modifying, self-extending AI environment.

Anthropic has already started migrating its own built-in features, such as the `diff` feature, into this Mud architecture. The long-term vision is to move more core functionalities into Muds, leaving a smaller, more flexible core for developers to reshape around their specific workflows. This creates a highly adaptive and extensible AI development platform.

An interesting experimental feature called 'You Should Know' further exemplifies this modularity. It involves a secondary agent that observes the main agent's actions, flagging potential issues or missed opportunities for either the user or Claude Code itself. This introduces a meta-level of supervision and refinement, where one AI agent helps improve another's performance.

This marks a new step in agentic engineering, where the very 'skills' or capabilities of an agent can be dynamically altered based on context or user needs. Muds don't just add external tools; they change the internal behavior of the harness and UI that orchestrate the agent. This means teams can implement sophisticated features like production safeguards, comprehensive auditing, context filtering, custom review agents, or entirely new interaction patterns and UIs directly within the AI's operational environment.

A crucial caveat mentioned is that, currently, Muds are not sandboxed. They run with Claude Code's full permissions, meaning installing a Mud is equivalent to installing arbitrary code on your machine. This implies a significant security consideration for developers adopting this technology, requiring careful vetting of Muds. However, architecturally, this approach suggests that coding agents are evolving from fixed applications into highly programmable operating environments, offering unprecedented control and customization for AI-powered development workflows.