GEAR: Feature-Based Configuration and Code Generation for Agentic Systems

Brell Sanwouo, Nada Zine, Paul Temple, Clément Quinton, Romain RouvoyarXiv 2026 · arXiv

TL;DR

GEAR is an open-source tool that introduces a framework-independent language for designing Multi-Agent Systems (MAS). By using "feature models" to define agent behaviors and workflows, it allows developers to validate their designs and automatically generate executable code for ten different popular frameworks like CrewAI, AutoGen, and LangGraph.

What Problem Does This Paper Address?

We are currently in a "Cambrian explosion" of Large Language Model (LLM) agent frameworks. Tools like CrewAI, AutoGen, and Google ADK offer powerful ways to orchestrate agents, but they all speak different "languages." They use different APIs, terminology, and abstractions for the same core concepts—like how an agent remembers past interactions or how a group of agents collaborates.

For developers and researchers, this creates two major headaches:

  1. Vendor/Framework Lock-in: Switching from one framework to another requires a complete rewrite of the system logic.
  2. Design Complexity: The configuration space for MAS is massive. Without a formal way to describe a design, it is easy to create "invalid" systems (e.g., choosing two orchestration strategies that conflict) that only fail at runtime.

Methods

The authors propose GEAR, a tool that separates the specification of a multi-agent system from its execution.

1. Feature Modeling

At the heart of GEAR is a Feature Model (FM). Borrowed from software engineering's "variability modeling" field, an FM is a hierarchical way to represent all possible configuration choices and the constraints between them.

Fig. 3: Excerpt of GEAR’s feature model.

As shown in Figure 3, GEAR breaks down a MAS into three main elements:

  • Agents: Properties like LLM model, tasks, tools, and memory.
  • Modules: Reusable orchestration structures (e.g., parallel vs. iterative loops).
  • Workflows: The "glue" that connects agents and modules into a functional flow.

2. The GEAR Pipeline

The tool follows a five-step workflow: Configure → Validate → Select Framework → Generate → Execute.

The architecture and processing pipeline of GEAR, showing the flow from specification to execution.
  • Validation: Before generating code, GEAR checks the design against the Feature Model's rules. If you try to use a feature that a specific framework doesn't support, or if your workflow has logical gaps, GEAR catches it early.
  • Connectors: GEAR uses a connector-based architecture. Each target framework has a specific "mapping registry" and code templates that translate the generic GEAR specification into framework-specific Python code.

Datasets

The authors did not use a traditional machine learning dataset. Instead, they performed a Preliminary Mapping Assessment by evaluating 32 core GEAR features against 10 different agentic frameworks: CrewAI, Google ADK, LangGraph, OpenAI Agents, Microsoft AF, Strands, PydanticAI, AutoGen, Semantic Kernel, and Haystack. This created a benchmark of 320 feature-framework pairs to test the feasibility of cross-framework generation.

Key Insights and Ideas

  • High Feasibility of Abstraction: The study found that 84.69% of the evaluated features could be mapped across the ten frameworks. This suggests that despite the surface-level differences in APIs, these frameworks share a deep commonality in how they handle agents and workflows.
  • Design-Time Validation: By using Feature Models, GEAR can detect "invalid" configurations (like missing API keys or incompatible orchestration strategies) before a single line of code is generated. This reduces the "trial and error" loop common in agent development.
  • Framework Comparison: GEAR enables "controlled comparisons." A researcher can design one MAS and generate versions for both CrewAI and AutoGen to see which framework performs better for a specific task without manually reimplementing the logic.

Key Results

The authors successfully implemented connectors for 10 frameworks. The mapping coverage varied by framework:

  • CrewAI had the highest coverage at 96.88% (31 out of 32 features mapped).
  • Google ADK followed closely at 93.75%.
  • PydanticAI had the lowest coverage at 71.88%, largely because some features were not exposed by the framework or remained implicit in its internal code.
Fig. 4: Coverage of identified mappings between GEAR fea- tures and target frameworks (% of features mapped per frame- work).

Overall, GEAR successfully identified translation strategies for 271 out of 320 pairs, proving that a framework-independent language for MAS is not just possible, but practical.

Limitations and Future Work

  • Advanced Features: The current version of GEAR focuses on core abstractions. Advanced, framework-specific capabilities like multimodal inputs (images/audio) and real-time streaming are not yet supported.
  • Manual Connector Effort: Adding a new framework to GEAR still requires significant manual effort to define the mappings and templates. The authors suggest that partially automating this process through "mapping inference" is a key direction for future work.
  • Behavioral Differences: While the code can be generated, the behavior of the agents might still differ slightly between frameworks due to internal implementation details. The authors plan to investigate these behavioral discrepancies more systematically.

For those interested in trying it out, GEAR is open-source and available on GitHub.

Summary updated

Abstract

Engineering multi-agent systems (MAS) requires choosing agents, orchestration strategies, communication mechanisms, reasoning approaches, and memory configurations. These choices depend on framework-specific capabilities and abstractions, requiring developers to learn different APIs when exploring alternative implementations. We present GEAR, an open-source tool for configuring MAS and generating framework-specific implementations from a common specification. GEAR uses a feature-based representation to make configuration options and their constraints explicit, enabling users to validate specifications before code generation. Through connectors for ten agentic frameworks, users generate projects from the same specification and can then inspect reports describing framework-specific adaptations. A preliminary assessment of mapping feasibility identifies translation strategies for 271 of 320 evaluated feature-framework pairs (84.69%). GEAR supports developers prototyping agentic systems and researchers exploring MAS configurations across frameworks. GEAR is available as open-source software at https://github.com/brellsanwouo/gear-framework and a video demo is available at https://youtu.be/iwNi-oC2tCw.
BibTeX
@misc{sanwouo2026gear,
  author = {Brell Sanwouo and Nada Zine and Paul Temple and Clément Quinton and Romain Rouvoy},
  title = {{GEAR: Feature-Based Configuration and Code Generation for Agentic Systems}},
  year = {2026},
  eprint = {2610.35592},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2610.35592},
}
Figure