LLMCompiler
AgentFree[ICML 2024] LLMCompiler: An LLM Compiler for Parallel Function Calling
Capabilities11 decomposed
llm-powered task decomposition with dependency graph generation
Medium confidenceThe Planner component uses an LLM to automatically decompose complex user queries into subtasks and generates a directed acyclic graph (DAG) representing task dependencies. It parses LLM outputs via StreamingGraphParser to extract task nodes, their input/output relationships, and execution constraints, enabling identification of parallelizable work without manual specification.
Uses LLM-in-the-loop planning with streaming graph parsing to generate executable task DAGs on-the-fly, rather than requiring users to manually specify task dependencies or using fixed rule-based decomposition. The Planner can generate plans incrementally and stream tasks to the executor before the full plan is complete.
More flexible than rule-based task decomposition (e.g., ReAct) because it adapts to problem structure via LLM reasoning, and faster than sequential function calling because it identifies parallelizable tasks automatically.
parallel function execution with dependency-aware task scheduling
Medium confidenceThe TaskFetchingUnit and Executor components implement a scheduler that respects task dependencies from the generated DAG, executing independent tasks concurrently while blocking dependent tasks until their inputs are available. The system maintains a task queue, tracks completion status, and collects results for aggregation, enabling wall-clock latency reduction through parallelism.
Implements a dependency-aware scheduler that extracts parallelism from task DAGs generated by the Planner, executing tasks concurrently while respecting input dependencies. Unlike sequential function calling (standard ReAct), this enables multiple independent tool calls to run simultaneously with automatic dependency resolution.
Reduces latency vs sequential function calling by 2-5x on multi-hop tasks with independent branches; more efficient than naive parallel execution because it respects dependencies and doesn't execute tasks prematurely.
react agent integration for iterative reasoning
Medium confidenceLLMCompiler can be integrated with ReAct (Reasoning + Acting) patterns where the agent iteratively reasons about the current state, decides on actions (tool calls), observes results, and repeats. This enables adaptive behavior where the agent can adjust its strategy based on intermediate observations.
Integrates ReAct-style iterative reasoning with LLMCompiler's parallel execution, enabling the agent to combine planned parallelism with reactive decision-making based on intermediate observations.
More flexible than pure planning because it allows mid-execution strategy changes; more efficient than pure ReAct because it exploits parallelism in independent tasks.
streaming task generation and incremental execution
Medium confidenceWhen enabled, streaming mode allows the TaskFetchingUnit to begin executing tasks as soon as they are generated by the Planner's LLM output stream, without waiting for the complete plan. The StreamingGraphParser incrementally parses LLM tokens into task objects, enabling pipelined planning and execution that reduces time-to-first-result and overall latency.
Implements streaming graph parsing that converts LLM token streams into executable task objects on-the-fly, enabling the executor to begin work before the Planner finishes generating the full plan. This pipelined approach reduces end-to-end latency by overlapping planning and execution phases.
Faster than batch planning (wait for full plan before execution) because it starts execution immediately; more responsive than traditional ReAct which waits for full LLM output before parsing.
multi-provider llm integration with unified interface
Medium confidenceLLMCompiler abstracts LLM provider differences through a unified model interface (src/utils/model_utils.py) that supports OpenAI, Azure OpenAI, Friendli, and vLLM backends. The framework handles provider-specific API calls, token counting, and response parsing, allowing users to swap providers without changing orchestration logic.
Provides a unified interface abstracting OpenAI, Azure OpenAI, Friendli, and vLLM with provider-agnostic method signatures, allowing the Planner and Executor to remain provider-agnostic while supporting both closed-source and open-source models.
More flexible than frameworks tied to a single provider (e.g., LangChain's OpenAI-centric design); enables cost optimization by switching providers without code changes.
replanning with execution context incorporation
Medium confidenceLLMCompiler can generate new execution plans based on results from previous attempts, incorporating execution history and intermediate results as context to the Planner. This enables the system to adapt when initial plans fail or produce unsatisfactory results, using feedback to refine task decomposition.
Enables the Planner to generate new execution plans conditioned on previous execution results and failures, treating replanning as a first-class capability rather than an error recovery afterthought. This allows the system to learn from execution and adapt decomposition strategies.
More adaptive than single-shot planning because it incorporates execution feedback; more efficient than naive retry because it generates new plans rather than re-executing the same failed plan.
tool registry and schema-based function calling
Medium confidenceLLMCompiler maintains a registry of available tools with structured schemas defining inputs, outputs, and descriptions. The Planner uses these schemas to generate valid function calls, and the Executor uses them to invoke tools with proper argument binding. This schema-driven approach ensures type safety and enables the LLM to reason about tool capabilities.
Implements a schema-driven tool registry where tools are defined with structured input/output schemas that the Planner uses to generate valid function calls. This enables type-safe, schema-validated function calling without manual argument binding.
More structured than string-based tool descriptions (e.g., ReAct with natural language tool specs); enables validation and type checking that reduces runtime errors.
result aggregation and answer synthesis
Medium confidenceThe LLMCompilerAgent component collects results from all executed tasks and synthesizes them into a final answer using the LLM. It maintains a mapping of task IDs to results, passes this context to the LLM, and generates a coherent response that incorporates all intermediate findings.
Uses the LLM itself to synthesize results from parallel task execution, treating synthesis as an LLM-powered reasoning step rather than simple concatenation. This enables intelligent interpretation and integration of diverse task outputs.
More intelligent than template-based result aggregation because it uses LLM reasoning to synthesize and interpret results; more flexible than fixed aggregation logic.
execution tracing and performance monitoring
Medium confidenceLLMCompiler tracks execution metadata including task timing, dependencies, tool invocations, and result sizes. This tracing enables performance analysis, debugging of failed executions, and identification of bottlenecks in task graphs. Traces can be logged and analyzed to optimize future executions.
Collects detailed execution traces including task timing, dependency resolution, and tool invocation metadata, enabling post-hoc analysis of execution behavior and performance bottlenecks.
More detailed than simple latency measurement because it tracks per-task timing and dependency resolution; enables identification of parallelism opportunities that sequential execution misses.
in-context example specification for few-shot planning
Medium confidenceLLMCompiler allows users to provide optional in-context examples (few-shot demonstrations) that show the Planner how to decompose similar problems. These examples are included in the Planner's prompt, enabling the LLM to learn task decomposition patterns from demonstrations rather than relying solely on instructions.
Enables few-shot learning for task decomposition by allowing users to provide example query-plan pairs that guide the Planner's LLM, improving plan quality without retraining or modifying the framework.
More flexible than fixed decomposition rules because it learns patterns from examples; more practical than retraining the LLM because it requires only example specification.
benchmark evaluation on multi-hop reasoning tasks
Medium confidenceLLMCompiler includes built-in evaluation on standard benchmarks (ParallelQA, HotpotQA, movie recommendations) that measure accuracy, latency, and cost of the framework on multi-hop reasoning tasks. These benchmarks enable quantitative comparison of planning strategies and execution efficiency.
Provides built-in evaluation on standard multi-hop reasoning benchmarks (HotpotQA, ParallelQA) with metrics for accuracy, latency, and cost, enabling quantitative assessment of planning and execution efficiency.
More comprehensive than simple accuracy measurement because it includes latency and cost metrics; enables direct comparison of parallel vs sequential execution on standard benchmarks.
Capabilities are decomposed by AI analysis. Each maps to specific user intents and improves with match feedback.
Related Artifactssharing capabilities
Artifacts that share capabilities with LLMCompiler, ranked by overlap. Discovered automatically through the match graph.
NLSOM
Natural Language-Based Societies of Mind
Colab demo
[GitHub](https://github.com/camel-ai/camel)
Qwen: Qwen3 30B A3B
Qwen3, the latest generation in the Qwen large language model series, features both dense and mixture-of-experts (MoE) architectures to excel in reasoning, multilingual support, and advanced agent tasks. Its unique...
BabyAGI
AI task management agent with autonomous execution.
"An open source Devin getting 12.29% on 100% of the SWE Bench test set vs Devin's 13.84% on 25% of the test set!"
SWE-agent works by interacting with a specialized terminal, which allows it to:
L2MAC
Agent framework able to produce large complex codebases and entire books
Best For
- ✓Teams building LLM agents that need to solve complex reasoning tasks (e.g., multi-hop QA, research synthesis)
- ✓Developers wanting to reduce manual orchestration overhead in tool-calling workflows
- ✓Applications with high-latency external tools (search, APIs, databases) where parallelism provides significant speedup
- ✓Multi-hop reasoning tasks (e.g., HotpotQA, complex research) where many independent searches can run in parallel
- ✓Complex tasks requiring adaptive behavior and mid-execution strategy changes
- ✓Scenarios where initial decomposition may be incomplete and needs refinement based on observations
- ✓Interactive applications where latency to first result matters (e.g., chatbots, real-time assistants)
- ✓Scenarios with many independent tasks where early execution of initial tasks provides value while planning continues
Known Limitations
- ⚠Plan quality depends on LLM capability — weaker models may generate suboptimal or invalid task graphs
- ⚠No built-in validation that generated plans are actually executable before submission to executor
- ⚠Streaming mode begins execution before full plan is available, risking replanning if dependencies are incomplete
- ⚠Parallelism benefit is limited by tool latency and number of independent tasks — CPU-bound operations see minimal speedup
- ⚠No built-in timeout or circuit-breaker logic for hanging tool calls; failed tasks block dependents indefinitely without explicit error handling
- ⚠Requires tools to be stateless or thread-safe; shared state across tool calls is not managed
Requirements
Input / Output
UnfragileRank
UnfragileRank is computed from adoption signals, documentation quality, ecosystem connectivity, match graph feedback, and freshness. No artifact can pay for a higher rank.
Repository Details
Last commit: Jul 10, 2024
About
[ICML 2024] LLMCompiler: An LLM Compiler for Parallel Function Calling
Categories
Alternatives to LLMCompiler
Are you the builder of LLMCompiler?
Claim this artifact to get a verified badge, access match analytics, see which intents users search for, and manage your listing.
Get the weekly brief
New tools, rising stars, and what's actually worth your time. No spam.
Data Sources
Looking for something else?
Search →