Can AI agents keep their flexible, everyday language while still making precise, binding commitments like older rule-bound systems did?
How can formal communication layers be added to LLM agents without sacrificing flexibility?
This explores how to give LLM agents the precise, rule-bound messaging of classic agent protocols (where a request means exactly one thing) without losing the open-ended natural language that makes them useful.
This explores how to give LLM agents the precise messaging of classic agent protocols without giving up the open-ended natural language that makes them useful. The short version from the corpus: the most promising answer is to stop treating this as a choice. Put the formal structure in the layer around the model, and let the model stay flexible inside it. No one in the collection has fully built this yet, though, and the hard part is still open.
It helps to see what formality bought us before LLMs. Older agent languages like KQML and FIPA-ACL gave every message a fixed meaning: a 'request' or a 'promise' committed the sender to something specific. That ruled out a failure LLM agents now show often. They overstep their scope, for example by contacting a third party when they were only allowed to answer directly Do LLM agents misinterpret delegated requests more than formal protocols?. Many breakdowns in multi-agent LLM systems look like what happens when that structure is missing. Agents swap roles mid-task, give empty replies, or loop forever, because nothing pins down who they are or what they've agreed to Why do autonomous LLM agents fail in predictable ways?. They also accept what neighboring agents tell them without checking it, so errors spread through the network Why do multi-agent systems fail to coordinate at scale?.
The design pattern that keeps coming up is to move structure *out* of the model and into the harness, the software that wraps it. One line of research argues that reliable agents don't come from bigger models. They come from offloading memory, skills, and *protocols* into that surrounding layer, so the model doesn't have to work out the rules of interaction again on every turn Where does agent reliability actually come from?. LLM Programs show the same idea from another direction. A plain algorithm controls the order of steps and what each step can see, while the LLM handles the fuzzy language work inside each step Can algorithms control LLM reasoning better than LLMs alone?. Flexibility survives because it is limited to where it helps. Work on norm-aware agents suggests the same split can hold for social rules: the model discovers and reasons about norms, and the architecture keeps track of what conforming means Can LLMs discover and apply social norms dynamically in open systems?.
Here is the catch you might not expect: the hard part isn't designing the protocol. It's translating between the two worlds. Efforts to plug LLMs into belief-desire-intention (BDI) agent architectures, the classic symbolic way of structuring agent reasoning, all depend on a layer that turns free-form LLM text into clean symbolic actions, and that layer doesn't yet exist in usable form How do we map LLM outputs into symbolic agent actions?. Turning a model into something that acts reliably likewise depends on the whole pipeline around it, not on retraining alone Can you turn an LLM into an agent by just fine-tuning?. Harness quality is also its own skill: models differ a lot in how well they build and maintain these layers, and you can't infer that from task scores Can language models build and maintain their own agent harnesses?.
A side benefit: once messages follow a formal structure, much of the communication becomes routine and well-defined. That's exactly the kind of work small language models handle well at a fraction of the cost Can small language models handle most agent tasks?. A formal protocol layer could therefore make agent systems cheaper as well as safer, with large models kept for the parts where open-ended interpretation actually matters. The gap in the corpus is clear, too: the pieces exist, but no validated system yet shows a hybrid of formal protocols and LLM language working end to end.
Sources 10 notes
KQML and FIPA-ACL use formal speech-act semantics to guarantee shared understanding of requests and commitments, while LLM agents relying on natural language risk overstepping scope—such as querying third parties when only direct queries were authorized.
Research identifies role flipping, flake replies, infinite loops, and conversation deviation as LLM-specific failures in multi-agent cooperation. These occur because LLMs lack persistent goal representation and stable role identity.
AgentsNet benchmark shows agents fail to coordinate strategies either by agreeing too late or adopting strategies without informing neighbors. Agents accept neighbor information without verification, enabling error propagation while remaining capable of detecting direct conflicts.
Research shows reliable LLM agents externalize three cognitive burdens—memory (state persistence), skills (procedural components), and protocols (structured interaction)—into a harness layer rather than relying on model scale alone. The harness unifies these externalities and eliminates the need for the model to solve the same problems repeatedly.
LLM Programs embed LLMs within explicit algorithms that manage control flow and state, presenting only step-specific context to each LLM call. This information hiding addresses capability and context window limits while treating complex reasoning as modular, debuggable sub-tasks.
Show all 10 sources
A plausible design exists to extend LLM-agent modules with norm discovery, reasoning, and conformance by leveraging existing capabilities like world knowledge and Theory-of-Mind reasoning, though no implementation has been validated.
Current proposals to integrate LLMs into BDI-style agent architectures depend on a translation layer between natural language and symbolic actions that does not yet exist in usable form. Prior neuro-symbolic work provides partial precedent, but was not designed for LLM-generated text.
Converting LLMs to action-capable systems requires four distinct stages: curating action-environment-user datasets, training for action grounding, integrating agent infrastructure with memory and tools, and rigorous safety evaluation. The surrounding system and harness determine whether actions are grounded or hallucinated.
Research shows that LLMs vary sharply in building harnesses across domains, struggle to retain useful intermediate updates during evolution, and produce harnesses whose performance shifts dramatically with different executors—demonstrating that harness quality cannot be inferred from downstream task scores alone.
SLMs handle the repetitive, well-defined language tasks that constitute most agent work at 10–30× lower cost than LLMs, making heterogeneous architectures (SLMs by default, LLMs selective) the economically rational design pattern.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Harness Updating Is Not Harness Benefit: Disentangling Evolution Capabilities in Self-Evolving LLM Agents
- Harnessing the power of LLMs for normative reasoning in MASs
- RRSI: Regularized Recursive Self-Improvement of Agent Harnesses
- Emergent Collusion in Long-Horizon LLM Agent Interaction
- Scaling Behavior of Single LLM-Driven Multi-Agent Systems
- Survey on Evaluation of LLM-based Agents
- Towards a Science of Scaling Agent Systems
- Externalization in LLM Agents: A Unified Review of Memory, Skills, Protocols and Harness Engineering