Recent research from UC Berkeley reveals a fundamental shift in how data systems will be used. AI agents don't just query differently than humans; they query at machine speed, generating hundreds of speculative queries per second in a process researchers call "agentic speculation." This shift creates new requirements for data infrastructure that most organizations haven't yet considered.
This paper examines the Berkeley research findings, explores what data platforms need to support agentic workloads effectively, and provides guidance for technical leaders preparing their infrastructure for this transformation.
When an AI agent analyzes a business problem (say, investigating declining quarterly revenue), it doesn't behave like a human analyst who carefully formulates a few targeted queries. Instead, the agent launches what Berkeley researchers describe as an "army of agents," each exploring different hypotheses simultaneously through rapid iteration:
Each of these exploration threads issues dozens of queries per second, building understanding through rapid speculation rather than careful, sequential analysis. This is agentic speculation: high-throughput exploratory querying where agents probe hundreds of potential solutions to identify the best course of action.
The Berkeley research team studied real agent behavior across text-to-SQL tasks and discovered several critical insights:
Scale Amplification: A single agent can theoretically issue hundreds or thousands of requests per second. When agents work in parallel, the query volume far exceeds anything human users would generate, all for a single analytical task.
Success Through Volume: Agent success rates improved by 14-70% when they could rapidly iterate through multiple attempts. But this improvement only materialized when queries returned in seconds, not minutes. When query latency increased, agents actually lost context and performance degraded.
The Redundancy Pattern: Only 10-20% of agent-generated query sub-plans were unique. Agents repeatedly explored similar table joins, aggregation patterns, and filtering logic, not because of poor design, but because they were essentially running Monte Carlo exploration of the data space.
Steering Potential: Agents reduced their query volume by over 20% when databases provided intelligent guidance (suggesting relevant tables, highlighting data quality issues, or providing cost estimates). The system became a collaborative partner rather than a passive responder.
The Berkeley research identifies four defining characteristics that separate agentic workloads from traditional database usage patterns:
Individual agents can issue thousands of requests per second, far exceeding human query patterns. A task like "analyze coffee sales trends" generates hundreds of parallel exploration queries across tables, columns, and aggregations. This isn't occasional burst traffic; it's sustained high-throughput querying as the fundamental operating mode.
Traditional data systems were designed for intermittent human queries or targeted application workloads. They struggle when faced with relentless speculation patterns at machine speeds.
Agent queries span from lightweight metadata discovery to complex analytical computations, often within the same task cycle. The Berkeley research observed distinct phases:
Unlike traditional BI workflows with predictable patterns, agents dynamically shift between these phases. They might explore metadata, attempt a partial query, return to gather more statistics, then formulate a complete solution, all within seconds.
Agents generate substantial overlapping work. The Berkeley team found that across 50 parallel attempts at the same task, distinct query sub-plans represented only 10-20% of total execution. This redundancy isn't wasteful from the agent's perspective; it's how agents explore the solution space efficiently.
This pattern creates massive opportunities for intelligent systems that can:
Agents can dramatically reduce query volume when provided with intelligent hints and grounding information. The Berkeley research showed that proactive system guidance reduced queries by 20%, with some query types seeing 36% reduction.
This steering takes multiple forms:
The key insight: effective agent systems require bidirectional communication, where the database acts more like an experienced data engineer providing context, not just a passive query executor.
Based on the Berkeley research findings, effective data platforms for agentic workloads require fundamentally different capabilities than traditional systems optimized for human users or application queries.
The iteration speed imperative: Agent effectiveness is primarily constrained by iteration speed, not feature sophistication. Agents think in rapid iteration loops:
This process breaks down completely when queries take more than a few seconds. Agents lose context, parallel threads fall out of sync, and iterative refinement degrades into inefficient sequential execution.
Consider the mathematics: if an agent needs 100 exploratory queries to solve a complex problem:
But the impact isn't linear; it's exponential. Faster iteration enables qualitatively different exploration strategies that wouldn't be possible with slower systems.
Agentic speculation creates heterogeneous workloads spanning lightweight metadata queries to complex analytical computations. Systems must handle this diversity without performance degradation.
The problem with specialized systems: Databases optimized for specific workload types struggle with agent patterns. Systems built for large batch queries create bottlenecks when agents need rapid iterations across many smaller queries. OLTP systems excel at point lookups but fail at analytical aggregations agents frequently require.
What's needed: Consistent performance across the full spectrum of query types agents generate. The same system that executes complex aggregations across billions of rows must also rapidly return table schemas, column statistics, and sample data, without creating queuing delays or resource contention between different query types.
The Berkeley research emphasizes that agent-first systems need flexible, modular architectures that can dynamically allocate resources based on speculation patterns.
Burst handling: When agents spawn multiple parallel exploration threads, systems must scale compute resources to handle burst loads without affecting other workloads. When exploration completes and agents move to solution formulation, resources should scale down appropriately.
The disaggregation advantage: Tightly-coupled architectures struggle with dynamic agent patterns. They're optimized for predictable workloads, not the variable resource demands of agentic speculation. Disaggregated designs that separate compute from storage enable the elastic scaling agents require.
With only 10-20% of agent query patterns being unique, systems that can identify and exploit redundancy gain massive efficiency advantages.
Beyond traditional caching: Simple query result caching isn't sufficient. Effective systems need:
The Berkeley paper identifies this as "multi-query optimization" specifically for agent workloads, where the system understands not just individual queries, but the exploration patterns agents follow.
The Berkeley research emphasizes that effective agent systems require flexible tool composition. Agents don't just query databases; they combine results with APIs, machine learning models, visualization tools, and other data sources.
The composition challenge: Purpose-built systems with proprietary interfaces create integration friction. Every tool combination requires custom work, slowing agent development and limiting flexibility.
What works: Standard protocols and interfaces enable seamless composition. When agents can use the same connection patterns across different tools, they maintain rapid iteration cycles without translation overhead. This is particularly important as agent frameworks evolve. Systems with standard interfaces adapt more easily than those with proprietary designs.
The 20%+ query reduction from intelligent steering demonstrates that passive query execution leaves significant efficiency on the table.
Going beyond answers: Modern data platforms for agents should:
The "sleeper agent" concept: The Berkeley paper proposes "sleeper agents" within databases that gather auxiliary information in parallel with query execution, returning both answers and guidance to external agents.
The Berkeley research concludes with a crucial insight: the future of data systems is modular and specialized, not monolithic and feature-comprehensive.
Specialization drives performance: Just as the best systems excel at specific requirements rather than trying to be "jack of all trades," agent-ready systems should focus on core capabilities that enable agent effectiveness while maintaining compatibility with evolving agent frameworks.
Ecosystem integration over vertical stacks: Effective agent systems require flexible tool composition. This favors architectures that deliver exceptional performance within standard interfaces over vertical integration requiring entire technology stack adoption.
Organizations should be able to:
History consistently shows that open standards and modular architectures win over proprietary, vertically-integrated solutions:
The same pattern is emerging for agent workloads. Rather than betting on proprietary agent-first architectures, forward-thinking organizations choose systems that excel at core requirements while maintaining compatibility with evolving agent standards.
The unproven architecture risk: Purpose-built "agent-first" systems remain largely theoretical. While the Berkeley research provides excellent insights into workload characteristics, translating those into production-ready systems involves significant engineering challenges:
The proven performance path: Organizations face a choice between waiting for purpose-built systems to mature or leveraging proven high-performance analytical databases that naturally align with agentic requirements. The latter provides:
Organizations should approach agent-ready infrastructure strategically, starting with use cases that immediately demonstrate value:
High-frequency analytical exploration: Business scenarios where agents rapidly iterate through multiple hypotheses (market analysis, customer segmentation, operational optimization). These use cases showcase how sub-second performance enables more sophisticated agent behaviors.
Mixed workload requirements: Applications where agents switch between lightweight exploration and complex computation. These demonstrate the value of consistent performance across query types.
Real-time decision support: Scenarios requiring agent recommendations based on current data (fraud detection, dynamic pricing, personalization engines). These applications reveal whether systems can maintain required performance characteristics.
When assessing infrastructure for agent workloads, organizations should prioritize:
Performance predictability: Proven performance characteristics under machine-speed analytical workloads rather than theoretical promises from unproven architectures.
Standards compliance: Platforms that excel at core requirements while maintaining compatibility with open standards and protocols.
Ecosystem integration: How well the platform integrates with existing analytical tools, machine learning frameworks, and data science workflows that agents will compose.
Roadmap alignment: Vendor roadmaps focused on core performance and compatibility improvements rather than proprietary agent-specific features that may limit future flexibility.
Effective implementation strategies enable gradual adoption while demonstrating incremental value:
Start with compatible standards: Systems supporting standard protocols enable teams to begin migration without rewriting application code or agent integration logic.
Leverage existing data formats: Platforms that work with existing data formats (like Apache Iceberg) eliminate migration requirements and enable immediate performance comparisons.
Scale dynamically: Begin with modest resources and scale based on agent workload requirements, optimizing costs while maintaining performance.
The Berkeley research suggests that agents will become the dominant workload for data systems. Organizations optimizing for agentic performance now gain significant advantages over those waiting for purpose-built solutions.
Compound impact across business scenarios:
The financial impact of agent performance differs from traditional database improvements:
Traditional analysis: Database performance improvements save analyst time. A 10x speedup might save 2-3 hours per week per analyst.
Agentic analysis: Performance improvements enable qualitatively different analytical capabilities. A 10x speedup doesn't just save time; it enables exploration strategies that were previously impossible, leading to insights and optimizations that wouldn't otherwise be discovered.
Real examples illustrate this difference:
Organizations considering infrastructure investments for AI workloads face significant risks around unproven technologies:
Technical risk reduction: Leveraging proven analytical performance already optimized for machine-speed workloads rather than betting on theoretical architectures.
Implementation risk mitigation: Standard interfaces and protocols minimize integration complexity and custom development requirements.
Vendor risk management: Established platforms with clear product roadmaps versus early-stage vendors with uncertain market positioning.
Future flexibility: Investment in proven analytical performance provides value regardless of how agent frameworks evolve.
Having established what data platforms need to support agentic workloads effectively, it's worth examining how Firebolt's existing architecture aligns with these requirements. This isn't because it was explicitly built as an "agent-first" system, but because its foundational design decisions map naturally to what agents need most.
Firebolt was architected around a core principle: analytical queries should return results in sub-seconds, not minutes. This design philosophy, originally intended for real-time analytical applications, maps precisely to agentic needs.
When agents fire off 50 parallel exploration queries, Firebolt's engine returns results in seconds rather than minutes. This maintains agent context, keeps parallel threads synchronized, and enables iterative refinement at machine speed.
Disaggregated design: Firebolt's separation of compute from storage enables the dynamic scaling that Berkeley's research identifies as crucial. When agents spawn multiple parallel exploration threads, compute resources automatically scale to handle burst loads. When exploration completes, resources scale down appropriately.
Mixed workload handling: The same Firebolt system that executes complex aggregations across billions of rows can rapidly return table schemas, column statistics, and sample data without performance degradation. This consistency across workload types eliminates the bottlenecks agents encounter in systems optimized for homogeneous patterns.
Intelligent optimization: Firebolt's query optimization includes sub-query reuse, tiered caching, and query pattern analysis. These capabilities enable the computation sharing Berkeley's research identifies as crucial for handling redundancy in agentic workloads.
Firebolt's PostgreSQL compatibility eliminates integration friction in agent workflows. When agents need to combine analytical results with operational data, application databases, or other tools, there's no protocol translation or format conversion. This compatibility advantage compounds over time as organizations build more sophisticated agent workflows involving multiple data sources.
While purpose-built "agent-first" systems remain largely theoretical, Firebolt delivers agentic-ready performance today:
Organizations can evaluate actual performance against their agent workloads rather than betting on unproven architectures.
For technical leaders interested in evaluating infrastructure for agentic workloads, we recommend:
The Berkeley research reveals a fundamental truth: AI agents represent a paradigm shift from human-speed to machine-speed analytical workloads. The systems that succeed in this era will be those that can maintain sub-second analytical performance under the massive parallel speculation patterns agents generate.
While the industry debates building specialized "agent-first" architectures from scratch, the more immediate opportunity lies in leveraging real-time analytical databases already optimized for the exact workload characteristics agents create. Speed, mixed workload consistency, dynamic scaling, and standards-based integration matter more than specialized agent features.
Organizations that recognize this reality early can capture competitive advantages while others wait for unproven systems to mature. As agents become the dominant interface for data systems, the performance gap between real-time analytical platforms and traditional systems will become a sustainable moat.
The agentic revolution is here. The question isn't whether AI agents will transform data system usage (the Berkeley research makes that transformation inevitable). The question is whether your organization will be ready with infrastructure that can keep up with how agents actually work.
______________________________________________________________
For technical leaders interested in exploring agent-ready infrastructure, we recommend starting with a pilot focused on your most query-intensive analytical use cases. Contact us for guidance on optimizing for agent workload patterns and measuring performance improvements against your current infrastructure.
%20logo.png){kind=icon}
