LangMARL: Natural Language Multi-Agent Reinforcement Learning via Semantic Credit Assignment

Huaiyuan Yao1*, Longchao Da1*, Xiaoou Liu1, Charles Fleming2, Tianlong Chen3, Hua Wei1
1Arizona State University, 2Cisco Research, 3University of North Carolina at Chapel Hill
*Equal Contribution

Accepted to EMNLP 2026 Main Conference

Credit assignment is the missing piece in self-evolving multi-agent LLM systems.

Global evaluation cannot pinpoint which agent is responsible; LangMARL decomposes team outcome into agent-specific credits.
Challenges in multi-agent credit assignment. Global evaluation tells the team that the order failed, but not who should change. Both agents produce vague, defensive reflections. LangMARL instead decomposes team performance into structured, agent-specific credits, so the agent that actually caused the failure receives a corrective signal while the agent that behaved well is reinforced.

Abstract

Large language model (LLM) agents struggle to autonomously evolve coordination strategies in dynamic environments, largely because coarse global outcomes obscure the causal signals needed for local policy refinement. We identify this bottleneck as a multi-agent credit assignment problem, which has long been studied in classical multi-agent reinforcement learning (MARL) but remains underaddressed in LLM-based systems.

Building on this observation, we propose LangMARL, a framework that brings credit assignment and policy gradient evolution from cooperative MARL into the language space. LangMARL introduces agent-level language credit assignment, pioneers gradient evolution in language space for policy improvement, and summarizes task-relevant causal relations from replayed trajectories to provide dense feedback and improve convergence under sparse rewards.

Extensive experiments across diverse cooperative multi-agent tasks demonstrate improved sample efficiency, interpretability, and strong generalization. Our code is available at github.com/DaRL-GenAI/LangMARL, with a tutorial at langmarl-tutorial.readthedocs.io.

Why do multi-agent LLM systems stop improving?

Most multi-agent LLM systems rely on hand-engineered prompts and static configurations, so agents cannot evolve their strategies as the task distribution shifts. When these systems do try to self-improve, they optimize against a single global outcome — a team-level success or failure — through global reflections or monolithic prompt rewrites. That signal simply is not informative enough: it never says which agent needs adjusting, which leads to inefficient learning or outright coordination collapse.

Classical MARL solved exactly this problem decades ago, with counterfactual baselines, value decomposition, and the centralized training, decentralized execution (CTDE) paradigm. But those tools assume numeric gradients over differentiable parameters. LLM agents are black boxes whose "parameters" are natural-language instructions. LangMARL closes that gap by re-deriving each MARL component in language space.

Comparison of Auto Prompt Engineer, Reflexion, TextGrad/Symbolic, and LangMARL optimization paradigms.
Where LangMARL sits among self-evolving paradigms. Auto Prompt Engineer updates each policy independently; Reflexion routes a global evaluation into per-agent memory; TextGrad and Symbolic Learning push a shared global evaluation into every policy. Only LangMARL converts the trajectory into an individual credit per agent before updating that agent's policy.
Method Self-EvolvingCentral CriticText GradientCredit Assignment
Static Prompting
CoT
Agents
Single-Agent Self-Evolving
AutoPE
DSPy
Reflexion
TextGrad
Multi-Agent Self-Evolving
Agent Neural Network
Symbolic Learning
LangMARL (ours)

Comparison across prompting and self-evolving paradigms. LangMARL unifies self-evolution, centralized critique, and explicit credit assignment.

How does LangMARL work?

Animated walkthrough of the LangMARL pipeline: decentralized rollout, centralized language critic, language policy gradient, and self-evolved coordination.
The LangMARL loop, stage by stage. A decentralized rollout produces one episodic trajectory; a centralized critic turns it into per-agent language credits; those credits become language policy gradients and a semantic policy update; and the agents that come out the other side have self-organized into complementary roles.

LangMARL follows a language CTDE loop. During training, a centralized critic sees the full episodic trajectory and attributes the outcome to individual agents in natural language. At execution time, each agent acts alone from its own language policy, with no access to global state or feedback. Four components mirror the standard actor–critic stack:

  • Language Policy Actor. Each agent i holds a text-parameterized policy πitext mapping a natural-language observation to a natural-language action. Its "parameters" are instructions, rules, and exemplars rather than numeric vectors.
  • Centralized Language Critic. Instead of estimating a scalar value, an LLM critic consumes the complete rollout and emits a structured, per-agent credit Citext(τ) describing how that agent's actions causally helped or hurt the episode. This is Monte-Carlo policy evaluation with a language-valued return.
  • Language Policy Gradient Estimator. A second LLM turns each agent's credit into a language-form update direction Δπitextk) — the language-space analogue of ∇θJ, computed without any numeric gradient.
  • Language Policy Optimizer. Gradients from a batch of trajectories are aggregated and applied as a semantic policy update, producing the next generation of each agent's policy text.
LangMARL system pipeline: language policy actor, centralized language critic, language policy gradient estimator, language policy optimizer, and the CTDE loop.
The LangMARL pipeline. (a) Each actor selects an action from its language policy and local observation. (b) The centralized critic reads whole trajectories and emits per-agent contribution credits. (c) The gradient estimator turns credits into policy critiques. (d) The optimizer synthesizes critiques into an improved policy. (e) The full centralized-training / decentralized-execution loop.

A toolkit that reads like TorchRL

LangMARL is packaged so that building an LLM multi-agent optimizer feels like writing a standard deep-RL pipeline. The abstractions map one-to-one onto familiar MARL library components — only the underlying representation changes from tensors to text.

Mapping between TorchRL abstractions and LangMARL abstractions: State, Policy Actor, Critic, Optimizer.
An easy-to-use toolkit. TensorDict becomes langmarl.State, ProbabilisticActor becomes langmarl.LLMActor, ValueOperator becomes langmarl.LLMCritic, and Adam becomes langmarl.LanguagePolicyOptimizer. Rollout, credit assignment, and the optimizer step keep the same syntax as classical MARL.

Does it work?

We evaluate on two families of environments: cooperative language tasks (HotPotQA, MATH, HumanEval, reframed as multi-agent RL problems) and strategic games with fixed roles and physical constraints (Overcooked-AI and Pistonball). LangMARL achieves the best result on every benchmark, against both static prompting and self-evolving baselines.

Method CoTAgents AutoPEDSPyReflexionTextGradSymbolic LangMARL
Natural Language Benchmarks (Accuracy / Pass Rate)
HotPotQA38.837.539.843.959.157.344.860.2
MATH23.223.822.517.349.453.838.856.0
HumanEval59.259.563.566.770.168.964.573.2
Overcooked-AI (Mean Reward)
Forced Coord.73.368.471.962.1138.585.3104.2148.9
Coord. Ring140.0122.3133.4141.4157.8163.8148.5184.4
Counter Circuit40.043.638.252.468.754.555.177.8
Asymm. Adv.226.7202.7143.5217.3204.1230.6232.4244.4
Cramped Room126.7118.5122.8145.7151.1131.3147.5171.4
Pistonball (Mean Reward)
N = 10-0.911.65.820.023.733.521.137.2
N = 12-0.1-2.7-0.87.8-6.224.33.129.6
N = 16-8.5-1.0-3.1-0.98.910.1-7.617.2
N = 20-11.5-3.8-6.2-7.3-1.214.33.322.9

Mean performance after 5 training iterations with the same backbone LLMs (GPT-3.5-turbo for language benchmarks, GPT-4o-mini for games). Notably, LangMARL keeps stable positive returns as the Pistonball team scales to N = 20, where baselines such as TextGrad degrade.

Training curves with and without centralized credit assignment across benchmarks.
Learning dynamics. With centralized credit assignment (orange), optimization converges faster and to a higher plateau on every benchmark. Without it (blue), training becomes unstable and settles into suboptimal plateaus — most visibly on MATH and Pistonball.

Is the credit assignment actually right?

We asked human annotators to identify the agent primarily responsible for the outcome across 70 Overcooked-AI trajectories (14 per layout). The critic's top attribution matched human judgment on 89.9% of trajectories, reaching 100% on Forced Coordination, where responsibility is unambiguous. This is direct evidence — independent of downstream task performance — that the critic captures real causal responsibility.

MetricForced Coord.Coord. RingCounter Circuit Asymm. Adv.Cramped Room
Human agreement 100.0%85.7%92.9%78.6%92.9%

Human verification of credit assignment quality on Overcooked-AI.

Ablation study on credit assignment.
Ablation on credit assignment. Replacing agent-wise credits with a single shared global reward causes a clear drop in both Overcooked-AI and Pistonball.
Layoutw/o Creditw/ CreditΔ
Forced Coord.82.7 ±61.1148.9 ±48.1+66.2**
Coord. Ring160.1 ±40.3184.4 ±30.9+24.3**
Counter Circuit30.9 ±36.477.8 ±40.4+46.9***
Asymm. Adv.227.3 ±59.8244.4 ±26.2+17.1
Cramped Room128.6 ±29.1171.4 ±28.9+42.8***

*** p < 0.01, ** p < 0.05, * p < 0.10.

Roles that nobody wrote down

Because credits are asymmetric — the critic praises one agent and corrects another — optimization pressure breaks the initial symmetry between identically-prompted agents. Over five epochs of collaborative coding, two generic problem solvers self-organize into complementary roles: Agent 1 specializes in structured implementation, Agent 2 in critical review and refinement. No role was ever specified in the prompt.

Emergent role specialization: two symmetric agents differentiate into implementer and critical reviewer.
Emergent role specialization in LangMARL. Top: the initial symmetric setup, with both agents acting as generic problem solvers. Bottom: after iterative trajectory-level credit assignment and language-based policy optimization, the agents settle into a complementary division of labor.
Worked examples of language credit assignment and policy optimization in Overcooked and Pistonball.
Credit assignment in action. (a) Overcooked: the critic analyzes a full trajectory, produces agent-specific credits, and revises Player Green's policy, improving coordination with Player Blue. (b) Pistonball: the critic identifies the causally responsible piston and assigns targeted credit, yielding a local policy that corrects the blocking behavior.

How robust is it across backbones and budgets?

LangMARL is backbone-agnostic. Across GPT-4o-mini, Gemini-3-Flash, and the open-weight LLaMA-3.3-70B, it beats the strongest baseline on both Coordination Ring and Forced Coordination — Gemini-3-Flash gives peak performance, while LLaMA-3.3-70B stays competitive.

Rollout budget behaves differently with scale. On few-agent tasks like HumanEval, more rollouts monotonically help. In large Pistonball teams the gain plateaus: beyond a point, extra rollouts amplify policy bias rather than coverage, so there is an optimal rollout frequency that shrinks as agent density grows.

Sensitivity analysis: LLM backbone comparison and rollout-count effects on HumanEval and Pistonball.
Sensitivity analysis. (a) LLM backbones against the strongest baseline, Reflexion. (b–c) Effect of Monte Carlo rollout counts on HumanEval and Pistonball.

Environments

Five Overcooked-AI layouts.
Overcooked-AI. Two agents cook and deliver soup across five layouts, acting through a hierarchical action space where semantic subgoals are translated into primitive movements.
Pistonball environment layouts.
Pistonball. A team of up to 20 pistons moves a ball together, with each agent seeing only a local vertical slice — severe partial observability under a sparse team reward.

What's next

Long-horizon agentic tasks. In workflows spanning hundreds of steps, such as autonomous software development, sparse rewards and error propagation attenuate the causal link between an intervention and the final outcome. Hierarchically decomposing long trajectories into semantic sub-goals would let the critic give more granular feedback.

Dynamic sub-agent synthesis. LangMARL currently operates over a pre-defined agent topology. We are working toward on-the-fly synthesis of specialized sub-agents, with dynamic task partitioning and evolving communication protocols.

From policies to skills. LangMARL optimizes each agent's policy text. MASkills extends the same language-space policy-gradient view to a richer unit of procedural knowledge — reusable, transferable agent skills.

BibTeX

@inproceedings{yao2026langmarl,
    title={LangMARL: Natural Language Multi-Agent Reinforcement Learning via Semantic Credit Assignment},
    author={Yao, Huaiyuan and Da, Longchao and Liu, Xiaoou and Fleming, Charles and Chen, Tianlong and Wei, Hua},
    booktitle={Proceedings of the 2026 Conference on Empirical Methods in Natural Language Processing (EMNLP)},
    year={2026},
    url={https://github.com/DaRL-GenAI/LangMARL},
}