Token Auction Model
To Optimize multiple LLM Agent Objectives
The integration of large language models (LLMs) into economic mechanisms represents a paradigm shift in how multi-agent systems collaborate to generate content. Google Research published a blog post on this through token auction model. By focusing on applications like AI-generated ad creatives, the framework enables self-interested LLM agents to influence joint outputs through strategic bidding while maintaining computational efficiency and incentive compatibility.
LLM Mechanism Design
Modern LLMs are very good at generating coherent text but has limitations/challenges when multiple stakeholders with competing preferences collaborate. Traditional auction mechanisms, which allocate discrete items like ad slots, struggle to handle the combinatorial nature of language generation. The token auction model addresses this gap/limitation by redesigning the auction model for sequential token generation.
At its core, the model treats each token (e.g., a word or phrase) as a decision point where LLM agents bid to influence the next token’s selection. This approach mirrors the autoregressive generation process of LLMs while introducing payment rules to align incentives. For example, in ad creative generation, airlines and resorts bid to include their branding in a shared output like “Fly with Alpha Airlines to Beta Resort’s tropical paradise”.
Multi-Agent Collaboration in Language Generation
When LLM agents represent stakeholders—such as advertisers, advertising agencies, or content creators—their preferences over generated text often conflict. Each agent’s LLM encodes implicit preferences through token probability distributions. For instance, an airline’s LLM might assign high probability to tokens like “direct flights”, while a hotel’s LLM favors “luxury suites”.
The main challenges in this setup are the following:
Preference Representation: LLMs distill complex preferences into token-level distributions but lack explicit value functions for full sequences.
Strategic Bidding: Agents may manipulate bids to skew aggregated outputs, necessitating incentive-compatible payment rules.
Computational Overhead: Aggregating distributions across multiple LLMs must not significantly slow down real-time generation2.
The Token Auction Model
The token auction operates iteratively, expanding a shared token sequence one token at a time. At each step:
Input: Each agent submits a bid bibi and a token distribution qiqi from their LLM.
Aggregation: A function q(b1,…,bn,q1,…,qn)q(b1,…,bn,q1,…,qn) combines distributions into a final token distribution.
Payment: A rule zi(b1,…,bn,q1,…,qn)zi(b1,…,bn,q1,…,qn) determines each agent’s payment.
Linear vs. Log-Linear Aggregation
Linear: The aggregated distribution is a bid-weighted average:
qlinear=∑biqi∑biqlinear=∑bi∑biqi
This favors high-bid agents proportionally but may dilute strong preferences.
Log-Linear: Transforms bids and distributions into log space for multiplicative blending:
qlog linear∝∏qibiqlog linear∝∏qibi
This amplifies consensus among agents, privileging tokens preferred by multiple high-bidders.
Design Space Reduction to Monotonicity
The first major theoretical result establishes that incentive-compatible mechanisms must use monotonic aggregation functions. Formally, if agent ii increases their bid bibi, the aggregated distribution must shift (weakly) in favor of ii’s preferences under their partial order ⪰i⪰i. This property ensures agents cannot gain by underbidding—a critical requirement for truthful bidding.
Building on monotonicity, the model derives generalized second-price (GSP) payments akin to search ad auctions. For each agent ii, the payment zizi equals the minimal bid required to maintain the same aggregation outcome had ii bid truthfully. This aligns incentives by ensuring agents pay the social cost of their influence.
Stable Sampling Implementation
The payment rule leverages a stable sampling technique, where a random seed ωωdetermines token selection thresholds. For fixed ωω, the threshold τi(ω)τi(ω) defines the bid level at which ii’s influence begins affecting outcomes. Payments then depend on these thresholds, ensuring computational tractability2.
Optimal Aggregation Rules
The final theoretical contribution characterizes aggregation functions that minimize social loss, defined as the weighted sum of agents’ dissatisfaction. Two loss formulations lead to linear and log-linear rules:
Linear Loss: Minimizes Llinear=∑bi⋅KL(q∥qi)Llinear=∑bi⋅KL(q∥qi), yielding linear aggregation.
Log Loss: Minimizes Llog=−∑bi⋅logqiLlog=−∑bi⋅logqi, yielding log-linear aggregation.
These results bridge mechanism design and machine learning, showing optimal aggregation aligns with standard training objectives like KL divergence minimization.
Ad Creative Generation Case Study
In a simulated ad auction, two agents (Alpha Airlines and Beta Resort) bid to influence a vacation-themed creative. Using GPT-4 with prompt tuning, the researchers demonstrate:
Low Bid Imbalance: With bids (1,1)(1,1), outputs blend both brands:
“Plan your Hawaiian getaway with Alpha Airlines’ affordable flights and Beta Resort’s beachfront suites.”High Bid Imbalance: At (3,1)(3,1), Alpha dominates:
“Fly direct to Honolulu with Alpha Airlines—Hawaii’s most trusted carrier.”
Aggregation Rule Comparison
Aggregation rules slightly introduce different modifications to the output for the model.
Linear: Smooth transitions between agent priorities, suitable for cooperative settings.
Log-Linear: Sharp transitions favoring consensus, ideal for competitive scenarios where overlap is minimal.
By operating token-by-token, the auction adds minimal overhead to LLM inference. Experiments show latency increases of <10% compared to single-LLM generation, making the approach feasible for real-time applications.
Advantages of the Approach
1. Minimal Preference Assumptions
Unlike traditional mechanisms requiring full utility functions, the model works with partial preference orders inferred from LLM distributions. This is critical given the black-box nature of modern LLMs.
2. Compatibility with Existing LLMs
The auction uses standard LLM outputs (token distributions) without requiring architectural changes. Demonstrations use off-the-shelf models like GPT-4, validated through prompt engineering.
3. Dynamic Incentive Alignment
Second-price payments adaptively penalize agents for marginal influence, preventing bid inflation. In simulations, truthful bidding emerges as a dominant strategy under monotonic aggregation.
4. Scalability to Multi-Modal Outputs
While focused on text, the framework generalizes to images, video, and other sequential media. Tokenization schemes like Stable Diffusion’s latent tokens could enable similar auctions for visual content.
Libraries
DeepSeek-V3, a strong Mixture-of-Experts (MoE) language model with 671B total parameters with 37B activated for each token. To achieve efficient inference and cost-effective training, DeepSeek-V3 adopts Multi-head Latent Attention (MLA) and DeepSeekMoE architectures, which were thoroughly validated in DeepSeek-V2. Furthermore, DeepSeek-V3 pioneers an auxiliary-loss-free strategy for load balancing and sets a multi-token prediction training objective for stronger performance. We pre-train DeepSeek-V3 on 14.8 trillion diverse and high-quality tokens, followed by Supervised Fine-Tuning and Reinforcement Learning stages to fully harness its capabilities. Comprehensive evaluations reveal that DeepSeek-V3 outperforms other open-source models and achieves performance comparable to leading closed-source models. Despite its excellent performance, DeepSeek-V3 requires only 2.788M H800 GPU hours for its full training. In addition, its training process is remarkably stable. Throughout the entire training process, we did not experience any irrecoverable loss spikes or perform any rollbacks.
smolagents is a library that enables you to run powerful agents in a few lines of code. It offers:
✨ Simplicity: the logic for agents fits in 1,000 lines of code (see agents.py). We kept abstractions to their minimal shape above raw code!
🧑💻 First-class support for Code Agents. Our CodeAgent writes its actions in code (as opposed to "agents being used to write code"). To make it secure, we support executing in sandboxed environments via E2B.
🤗 Hub integrations: you can share/pull tools to/from the Hub, and more is to come!
🌐 Model-agnostic: smolagents supports any LLM. It can be a local transformers or ollama model, one of many providers on the Hub, or any model from OpenAI, Anthropic and many others via our LiteLLM integration.
👁️ Modality-agnostic: Agents support text, vision, video, even audio inputs! Cf this tutorial for vision.
🛠️ Tool-agnostic: you can use tools from LangChain, Anthropic's MCP, you can even use a Hub Space as a tool.
Textual-Edge Graphs (TEGs) incorporate textual content on both nodes and edges, unlike Text-Attributed Graphs (TAGs) featuring textual information only at the nodes. Edge texts are crucial for understanding document meanings and semantic relationships. For instance, as shown below, to understand the knowledge "Planck endorsed the uncertainty and probabilistic nature of quantum mechanics," citation edge (Book D - Paper E) text information is essential. This reveals the comprehensive connections and influences among scholarly works, enabling a deeper analysis of document semantics and knowledge networks.
s1: Simple test-time scaling is a minimal recipe for test-time scaling and strong reasoning performance matching o1-preview with just 1,000 examples & budget forcing.
Pathway is a Python ETL framework for stream processing, real-time analytics, LLM pipelines, and RAG.
Pathway comes with an easy-to-use Python API, allowing you to seamlessly integrate your favorite Python ML libraries. Pathway code is versatile and robust: you can use it in both development and production environments, handling both batch and streaming data effectively. The same code can be used for local development, CI/CD tests, running batch jobs, handling stream replays, and processing data streams.
Pathway is powered by a scalable Rust engine based on Differential Dataflow and performs incremental computation. Your Pathway code, despite being written in Python, is run by the Rust engine, enabling multithreading, multiprocessing, and distributed computations. All the pipeline is kept in memory and can be easily deployed with Docker and Kubernetes.
Shortest is an AI-powered natural language end-to-end testing framework.
It has the following capabilities:
Natural language E2E testing framework
AI-powered test execution using Anthropic Claude API
Built on Playwright
GitHub integration with 2FA support
Email validation with Mailosaur
Midscene.js lets AI be your browser operator 🤖.Just describe what you want to do in natural language, and it will help you operate web pages, validate content, and extract data. Whether you want a quick experience or deep development, you can get started easily.
Below The Fold
PL/Rust is a loadable procedural language that enables writing PostgreSQL functions in the Rust programming language. These functions are compiled to native machine code. Unlike other procedural languages, PL/Rust functions are not interpreted.
The primary advantages of PL/Rust include writing natively-compiled functions to achieve the absolute best performance, access to Rust's large development ecosystem, and Rust's compile-time safety guarantees.
PL/Rust provides access to Postgres' Server Programming Interface (SPI) including dynamic queries, prepared statements, and cursors. It also provides safe Rust types over most of Postgres built-in data types, including (but not limited to), TEXT, INT/BIGINT, NUMERIC, FLOAT/DOUBLE PRECISION, JSON/JSONB, arrays, and more. You can also use PL/Rust to write trigger functions.
This post discusses a project to visualize all books in ISBN (International Standard Book Number) space, which was published on February 3, 2025. Here's a summary of the key points:
The author created an interactive visualization of the entire ISBN space, which contains approximately 2 billion slots for books. This visualization allows users to explore books based on various criteria such as publication date, publisher, and availability in digital formats
Maturin can build and publish crates with pyo3, cffi and uniffi bindings as well as rust binaries as python packages with minimal configuration. It supports building wheels for python 3.8+ on Windows, Linux, macOS and FreeBSD, can upload them to pypi and has basic PyPy and GraalPy support.
microsoft/go contains the infrastructure Microsoft uses to build Go. The submodule named go contains the Go source code. By default, the submodule's remote URL is the official GitHub mirror of Go, golang/go. The canonical Git repository for Go source code is located at https://go.googlesource.com/go.
OmniParser is a comprehensive method for parsing user interface screenshots into structured and easy-to-understand elements, which significantly enhances the ability of GPT-4V to generate actions that can be accurately grounded in the corresponding regions of the interface.