An Interpretable Automated Mechanism Design Framework with Large Language Models

TL;DR

The paper reframes mechanism design as a code-generation problem using large language models (LLMs) to generate interpretable mechanism implementations. It introduces the AMD-LLM framework and an extended NN-assisted variant (NNA-AMD-LLM), both paired with a problem-specific fixing process to enforce $SP$ and $IR$ while optimizing performance. Through experiments including rediscovery of Myerson's virtual valuation, welfare-maximization with VCG redistribution, and revenue-maximization under correlated bidders, the approach achieves competitive or superior performance with human-readable code compared to neural-network-only methods. This work demonstrates that LLM-driven code generation can scale mechanism design while improving interpretability, safety, and insight into complex economic problems.

Abstract

Mechanism design has long been a cornerstone of economic theory, with traditional approaches relying on mathematical derivations. Recently, automated approaches, including differentiable economics with neural networks, have emerged for designing payments and allocations. While both analytical and automated methods have advanced the field, they each face significant weaknesses: mathematical derivations are not automated and often struggle to scale to complex problems, while automated and especially neural-network-based approaches suffer from limited interpretability. To address these challenges, we introduce a novel framework that reformulates mechanism design as a code generation task. Using large language models (LLMs), we generate heuristic mechanisms described in code and evolve them to optimize over some evaluation metrics while ensuring key design criteria (e.g., strategy-proofness) through a problem-specific fixing process. This fixing process ensures any mechanism violating the design criteria is adjusted to satisfy them, albeit with some trade-offs in performance metrics. These trade-offs are factored in during the LLM-based evolution process. The code generation capabilities of LLMs enable the discovery of novel and interpretable solutions, bridging the symbolic logic of mechanism design and the generative power of modern AI. Through rigorous experimentation, we demonstrate that LLM-generated mechanisms achieve competitive performance while offering greater interpretability compared to previous approaches. Notably, our framework can rediscover existing manually designed mechanisms and provide insights into neural-network based solutions through Programming-by-Example. These results highlight the potential of LLMs to not only automate but also enhance the transparency and scalability of mechanism design, ensuring safe deployment of the mechanisms in society.

Figures (7)

• Figure 1: The workflow for frameworks AMD-LLM (following the "without NN" branch) and NNA-AMD-LLM (following the "with NN" branch).
• Figure 2: The best average score (so far, in last five iterations) by evolution iteration, using NNA-AMD-LLM, on VCG redistribution mechanism design. The blue boxes contain some example heuristics generated, from the corresponding positions in the evolutionary process, pointed at by the blue arrows.
• Figure 3: The best average score (so far, in last five iterations) with the evolution iteration, using AMD-LLM, on VCG redistribution mechanism design.
• Figure 4: The curve shows the best score so far with the evolution iteration goes on. We can see the best score so far gradually increases. The green boxes contain some example heuristics generated by Llama-3.1-70B-Instruct model, from the corresponding positions in the evolutionary process pointed at by the green arrows.
• Figure 5: Best Revenue Score achieved with k iterations for several models. The 4 sample programs are heuristic functions output by the LLama-3.1-70B-Ins model from different evolution sample iterations (0, 10, 50, 100, respectively), pointed at by the green arrows. From this result, we can observe that the model can improve upon existing methods by updating the parameters (from using linspace 1 and 0.5 to using linspace 1 and 0.1 in their code), or come up with new ideas (convolve).

Theorems & Definitions (2)

• definition 1: Fixing process
• proposition 1