DeLM Framework: Decentralized Multi-Agent Coding at 50% Lower Cost Than Centralized Approaches

A New Architecture That Cuts Multi-Agent Costs in Half

A new research paper introduces DeLM (Decentralized Language Model) — a framework for multi-agent coding that eliminates the central controller bottleneck and achieves state-of-the-art SWE-bench Verified scores while reducing per-task costs by approximately 50% compared to centralized multi-agent approaches. The system outperforms baselines by +10.5 percentage points on the benchmark, proving that cheaper doesn't mean less capable.

For teams running multi-agent coding workflows — increasingly common for complex codebases — DeLM's architecture offers a blueprint for dramatically reducing costs without sacrificing task completion quality.

Why Centralized Multi-Agent Systems Are Expensive

Current multi-agent coding tools (like Devin's internal architecture, OpenAI's Codex, and various SWE-agent implementations) typically use a centralized controller pattern: one "manager" agent coordinates multiple "worker" agents, routing tasks, synthesizing results, and maintaining global state.

This architecture has three cost problems:

Controller overhead: The central agent processes every worker's output, making it a token-consumption bottleneck. For a 5-agent system solving a complex task, the controller might consume 40-60% of total tokens just coordinating — not doing productive work. It reads every file the workers read, processes every result, and generates routing decisions.

Sequential dependency chains: Workers often wait for the controller to process previous outputs before receiving their next assignment. This serialization means expensive model time is wasted on idle workers while the controller thinks. Parallelism is limited by the controller's processing speed.

Redundant context loading: In centralized systems, context flows through the controller to workers. Each piece of relevant code gets tokenized multiple times — once when the controller reads it, again when it passes context to each worker. This duplication multiplies token costs linearly with agent count.

DeLM's Decentralized Approach: Shared Context, No Controller

DeLM replaces the central controller with two mechanisms:

Shared verified context: Instead of routing information through a controller, agents share a common context pool. When one agent verifies a fact about the codebase (function signature, test behavior, dependency relationship), that verified information becomes available to all agents without re-processing. This eliminates the redundant tokenization problem — information is processed once, shared many times.

Task queue with self-assignment: Rather than a controller deciding what each agent works on, agents pull from a shared task queue based on their current context and capabilities. This eliminates controller overhead entirely and allows true parallelism — no agent waits for routing decisions.

The result: agents spend tokens on productive work (reading code, generating solutions, running tests) rather than on coordination overhead. The architecture naturally scales — adding more agents increases throughput without proportionally increasing coordination costs.

The Numbers: 50% Cost Reduction, Better Results

On SWE-bench Verified (the standard benchmark for AI coding agent capability), DeLM achieved the highest scores while using approximately half the tokens per task compared to centralized multi-agent baselines. Specific results:

+10.5 percentage points over the best centralized baseline on task completion rate. This isn't a marginal improvement — it represents a significant leap in capability.

~50% reduction in cost per task measured by total token consumption. For a task that costs $2.00 with a centralized multi-agent system, DeLM completes it for approximately $1.00.

The cost savings come primarily from eliminating controller token consumption (saves ~40% of overhead) and reducing redundant context processing through the shared verification pool (saves additional ~20-30% on context tokens).

Implications for Multi-Agent Coding Tool Pricing

If tools adopt DeLM-style architectures, the cost of multi-agent coding could drop significantly. Consider current pricing:

A complex feature that requires multi-agent coordination (e.g., modifying 5+ files across a codebase) currently costs $3-$10 per task on platforms like Devin or Codex. With DeLM's 50% reduction, the same tasks could run for $1.50-$5.00. For teams running 50-100 such tasks daily, that's $75-$250/day in savings — or $1,500-$5,000/month.

More importantly, the better completion rate means fewer retries. If a centralized system completes 40% of tasks on first attempt versus DeLM's 50.5%, the effective cost difference is even larger because failed attempts still consume full token budgets.

What This Means for the Multi-Agent Market

DeLM validates a broader architectural trend: the future of multi-agent systems is decentralized. As commercial tools adopt these patterns, expect multi-agent coding costs to continue falling throughout 2026-2027. Teams currently avoiding multi-agent tools due to cost concerns should revisit the economics as decentralized architectures reach production tooling.

The research also suggests that simpler architectures can outperform complex ones when properly designed. This is good news for open-source implementations — the decentralized pattern is easier to implement than sophisticated controller logic, potentially accelerating open-source multi-agent tool development.