One of the biggest risks in LLM-powered multi-agent systems is that a conversation can look intelligent while remaining structurally unreliable.
The response quality may seem high, but there is no clear answer to basic engineering questions:
- Which moves were legal?
- Who was allowed to reply next?
- Why did the session terminate?
- What evidence was actually exchanged?
- Can the same session be replayed later?
This is why STRATON-LLM uses a finite-state protocol engine.
What the protocol engine does
The engine owns the negotiation session.
It manages:
- session creation
- turn order
- message validation
- dialogue act legality
- termination conditions
This means the LLM does not control the entire conversation. It proposes content inside a bounded conversation structure.
A tiny negotiation walkthrough
Consider a mismatch around price and rate.
Initial state
State: WAIT_FOR_TRIGGER
The incoming message causes a low-confidence semantic lookup.
Negotiation starts
State: SESSION_OPEN
Allowed acts: propose, request_evidence
The system opens a formal session.
Claim is made
Act: propose
Content: price is semantically equivalent to rate in this booking context
The engine records the proposal and transitions to a state where challenge or support is legal.
Evidence is requested
Act: request_evidence
Content: define rate and provide the context constraints under which it applies
This is important. The responder is not forced to accept or reject immediately.
Support and defense
Act: support
Content: rate is the monetary amount applied per booking unit in this domain
Act: defend
Content: in this conversation, price refers to the same booking unit amount requested by the travel agent
Now the engine has a structured history rather than a shapeless transcript.
Session closes
State: READY_FOR_EVALUATION
The engine terminates once the dialogue reaches a legal stopping condition.
Why this matters
Without protocol control, negotiation quality is mostly judged by surface plausibility.
With protocol control, the system can inspect:
- the number of turns
- the kinds of acts used
- whether evidence was requested
- whether attacks were answered
- whether the final acceptance was suspiciously fast
This enables the next layer: agreement evaluation.
The architectural benefit
Protocol control also improves software quality.
It makes the system:
- easier to debug
- easier to test
- easier to benchmark
- easier to explain in a research setting
A protocol transcript is not just useful for the machine. It is useful for the engineer and the evaluator.
The deeper point
LLMs are strong at generating candidates, explanations, and argument fragments.
But a research-grade negotiation system still needs an explicit control spine. In STRATON-LLM, that spine is the protocol engine.
It is the reason the project can claim more than “the agents talked and eventually agreed.”
It can say how they talked, why the session ended, and whether the agreement deserves trust.