Pushdown: How AI agents get smarter with MCP
Published by Darshan Joshi in Engineering in AI
Copy Link
Table of contents
The Problem: When Agents Become Data Hogs
Types of Pushdown
Requirements for MCP-Enabled Pushdown
How Ema Agents Utilize Pushdown Capabilities
The Call to Action
Conclusion
For decades, data integration software and ETL pipelines have used pushdown techniques to reduce network costs and improve efficiency by moving computation closer to the data source. Now, as AI agents increasingly access enterprise systems, these same techniques are becoming relevant again—only this time through the lens of the Model Context Protocol (MCP). By leveraging pushdown techniques, AI agents can overcome data bottlenecks and make intelligent and efficient use of data assets.
The Problem: When Agents Become Data Hogs
Imagine an AI agent helping a sales manager answer: "Show me active customers in California who have placed orders over $10,000 in the last quarter."
Without pushdown thinking, this simple request becomes a data nightmare. The agent pulls thousands of customer records, downloads months of order history, then performs joins and filters locally—recreating the classic ETL bottleneck that enterprises spent decades solving.
Inefficient Approach: Agent-Side Processing
// Tool 1: Get all customers
{
"name": "get_customers",
"description": "Retrieve customer data",
"inputSchema": {
"type": "object",
"properties": {
"limit": {"type": "integer", "default": 1000}
}
}
}
// Tool 2: Get all orders
{
"name": "get_orders",
"description": "Retrieve order data",
"inputSchema": {
"type": "object",
"properties": {
"limit": {"type": "integer", "default": 1000}
}
}
}
What happens:
- Agent calls get_customers() → Downloads 10,000+ customer records
- Agent filters "California" customers locally
- Agent calls get_orders() → Downloads 50,000+ order records
- Agent filters orders for ">$10,000" and "last quarter" locally
- Agent performs join operation in memory and returns 23 matching results to sales manager
Cost: 60,000+ records transferred, extensive client-side processing, high latency
MCP's Role: The Bridge That Enables Intelligence
With MCP and proper pushdown design, the same query can become a single, efficient operation that leverages the underlying SaaS system's optimized query engine.
MCP is not a query planner or execution engine. It does not itself decide how to apply pushdown. Instead, MCP defines a structured protocol for how agents discover and interact with external systems. This means pushdown only works when:
- The MCP server exposes structured capabilities reflecting what operations underlying systems support
- The agent maps user intent into those capabilities instead of resorting to brute-force data pulls
Without both ends working intelligently, agents risk reinventing the "ETL bottleneck" problem in a new form.
Efficient Approach: Processing with Pushdown
// Single optimized tool with pushdown capabilities
{
"name": "query_customers_with_orders",
"description": "Query customers with order filters using CRM's optimized join engine",
"inputSchema": {
"type": "object",
"properties": {
"customer_filters": {
"type": "object",
"properties": {
"state": {"type": "string"},
"status": {"enum": ["active", "inactive", "prospect"]},
"industry": {"type": "string"},
"created_after": {"type": "string", "format": "date"}
}
},
"order_filters": {
"type": "object",
"properties": {
"amount_min": {"type": "number"},
"amount_max": {"type": "number"},
"date_range": {
"type": "object",
"properties": {
"start": {"type": "string", "format": "date"},
"end": {"type": "string", "format": "date"}
}
},
"status": {"enum": ["pending", "completed", "cancelled"]}
}
},
"customer_fields": {
"type": "array",
"items": {"type": "string"},
"description": "Specific customer fields to return"
},
"order_fields": {
"type": "array",
"items": {"type": "string"},
"description": "Specific order fields to return"
},
"limit": {"type": "integer", "default": 100},
"offset": {"type": "integer", "default": 0}
}
}
}
What happens:
- Agent introspects MCP server capabilities and determines it can do full pushdown
- Single call: query_customers_with_orders() with all filters and field selections
- CRM system executes the entire operation including filters and joins and returns 23 matching records.
Cost: 23 records transferred with optimized processing, minimal latency
Types of Pushdown
- Predicate Pushdown: This technique applies filters (like a WHERE clause) at the data source. For example, a query for "customers in California" will filter out irrelevant data at the application, so only the data for California customers is ever transferred.
- Projection Pushdown: Optimizing Data Retrieval: This optimization technique enhances efficiency by selectively retrieving only the necessary columns or attributes from a table or object. This approach significantly reduces data transfer and memory consumption, particularly beneficial for objects containing numerous attributes.
- Join Pushdown: This delegates the JOIN operation to the underlying application. If two objects or tables are from the same source, it's far more efficient to join them there than to pull both massive datasets into the agent's memory to perform the join.
- Aggregation Pushdown: This moves aggregation functions like COUNT, SUM, and AVERAGE to the application. The application calculates the final value and returns a single, eliminating the need to transfer and process a huge volume of raw data.
- Limit/Top-N Pushdown: When an agent only needs a specific number of records (e.g., LIMIT 10), this technique instructs the application to find and return only those top records, which is much faster than processing the entire dataset and then aggregating it.
Requirements for MCP-Enabled Pushdown
Getting pushdown optimization through MCP isn't automatic—it requires alignment across three critical layers:
1. Underlying Applications Must Expose Rich Capabilities
The foundation starts with the enterprise system itself. A CRM, ERP, or database must offer more than basic CRUD operations. Specifically, they must provide sophisticated query capabilities and field level access controls. Without these underlying capabilities, no amount of MCP sophistication can create performance that doesn't exist.
2. MCP Servers Must Surface These Capabilities Intelligently
Agents perform poorly when an MCP server only exposes basic "get all records" kind of endpoints, wasting the underlying system's optimization potential. Effective MCP servers must design tool schemas that mirror backend query capabilities, expose filtering parameters that map to system-native operations, support relationship operations that leverage backend engines.
3. Agents Must Use These Capabilities Wisely
Even with rich server capabilities, the AI agent must make intelligent choices. This requires:
- Schema-aware query planning that maps user intent to available optimizations
- Performance-conscious tool selection that minimizes data movement
- Understanding when to use single optimized calls versus multiple simple ones
- Graceful degradation when optimal tools aren't available
When Proper Pushdown Isn't Used:
The consequences of ignoring pushdown optimization compound quickly:
- Data Transfer Explosion: Transferring content of entire objects or tables instead of needed data
- Network Bottlenecks: Multiple round trips instead of single optimized query
- Processing Inefficiency: Agent-side operations consuming agent resources instead of applications-optimized operations
- Cost Escalation: Higher API usage, bandwidth consumption, and compute resource utilization
- Performance Degradation: What should be sub-second responses become multi-second delays
- Scalability Limits: Approaches that work for hundreds of records fail catastrophically with thousands
- Potential Compliance Issues: In enterprise contexts, these inefficiencies aren't just slow—they're expensive and can violate compliance requirements by unnecessarily exposing sensitive data.
How Ema Agents Utilize Pushdown Capabilities
Ema’s agents utilize technical discovery through MCP servers and intelligent decision-making.
Step 1: Capability Discovery When connecting to an MCP server, agents receive a catalog of available tools, resources, and prompts. Each tool comes with a detailed schema describing supported parameters, filter options, field selections, and operational capabilities.
Step 2: Schema Analysis Agents analyze these schemas to understand the optimization landscape. What filtering parameters exist? Which tools support relationship operations? Are there pre-built aggregation functions? This analysis creates a capability map for query planning.
Step 3: Intent MappingWhen processing user requests, agents must map natural language intent to available technical capabilities. "Show me California customers with large recent orders" becomes a structured set of filter parameters, field selections, and join operations.
Step 4: Optimization Selection Given the capability map and structured intent, agents choose the optimal execution path. Single complex call or multiple simple ones? Native aggregations or client-side calculation? The decision directly impacts performance. In some cases, an agent may have to settle with partial pushdown. See next section.
Step 5: Execution and Learning Execute the optimized calls and monitor performance. Track what works well and identify patterns for future optimization. Build institutional knowledge about effective pushdown strategies for each system.
This process transforms agents from blind data consumers into intelligent collaborators that respect the computational architecture of enterprise systems.
Partial Pushdown
What if an application or MCP server doesn't fully support the capabilities needed for a complete pushdown, such as a join operation? In such scenarios, the agent must leverage available pushdown capabilities and gracefully handle the situation. This approach ensures efficiency and better performance compared to having no pushdown at all.
The Call to Action
For MCP Server Designers
- Expose Rich Query Interfaces: Design tools like query_customers_with_orders that mirror native join and filter capabilities
- Provide Comprehensive Schemas: Include detailed field definitions, filter options, and relationship mappings so agents can make intelligent pushdown decisions
- Support Progressive Complexity: Offer both high-level domain operations and flexible query tools for different use cases
- Include Performance Hints: Add metadata about query costs and optimization recommendations
For the MCP Ecosystem
- Standardize Patterns: Establish conventions for common patterns across different systems
- Create Performance Benchmarks: Develop tools for measuring and comparing pushdown effectiveness
- Share Implementation Examples: Build reference implementations showing optimal pushdown patterns
Conclusion
The Model Context Protocol (MCP) transcends a mere integration standard, offering an opportunity to develop AI agents that respect and leverage decades of application optimizations. By facilitating the structured discovery and utilization of pushdown capabilities across CRMs, ERPs, databases, and analytics platforms, MCP can transform agents into intelligent collaborators rather than costly data consumers.
But this transformation isn't automatic. It requires thoughtful MCP server design that exposes rich capabilities, intelligent agent development that exploits optimization opportunities, and organizational commitment to performance-aware architecture.
The enterprises that embrace pushdown-aware agents today will set the standard for efficient AI integration. Those that ignore these principles will find themselves struggling with scale, cost, and performance as their agent deployments grow.
The real revolution isn't connecting agents to enterprise systems – it's teaching agents to be intelligent citizens of the computational ecosystems they inhabit.