Why LLM chat feels like an anti-pattern in 2026

A continuation of my previous article, What is better than your AI loop?, which introduced the blackboard architecture this post builds on.

The chat. The message-response chain you produce by typing with an LLM. It could be trivially implemented by a single growing context or a sliding window.

Why does it feel like an anti-pattern to me? Chat as a UI is fine, chat as a world model is not.

Speech Act Theory, pioneered by J.L. Austin, tells us that language is a form of action. In his 1955 lectures, published posthumously in 1962 as How to Do Things with Words [1], Austin dismantled the idea that sentences merely describe reality, introducing "performatives" - expressions changing the world state. (Coincidentally, 1962 is also the year the first "blackboard" appeared in the AI literature [2].) Later on, John Searle systematized the field, sorting speech acts into five distinct types (Representatives, Directives, Commissives, Expressives, Declarations) [3], and this taxonomy transitioned from philosophy to computer science and AI.

With the emergence of Multi-Agent Systems (MAS) in the 1990s, the traditional RPC style of communication became a bottleneck. The request-response was an impedance mismatch. Independent software programs needed to negotiate, plan, share knowledge. Autonomous agents required loose coupling simply to remain autonomous. An agent must be able to refuse a command, negotiate a task or report status on its own.

To standardize this for machines, the early 1990s brought KQML (as part of the DARPA Knowledge Sharing Effort) [4]. The Foundation for Intelligent Physical Agents (FIPA) released the FIPA-ACL specification in 1997 [5]. They grounded agent communication in Belief-Desire-Intention (BDI) modal logic (logic extended by necessity and possibility statements/operators). This brought problematic preconditions, for example: to use Inform, the agent must believe the proposition and not believe the receiver already knows it. That is unverifiable and the equivalent of mind reading. This rigid codification in FIPA-ACL was ultimately a hard problem, which is now elegantly (and perhaps unintentionally) approximated/solved by LLMs for free.

The formal schema wasn't widely adopted by today's LLM agents. Modern multi-agent frameworks (such as AutoGen [6] or LangGraph) largely abandoned strict modal logic. Instead they drifted towards natural language schemas and JSON wrappers (e.g. the OpenAI function-calling schema introduced in 2023). However, the foundational principles of Speech Act Theory remain present and identifiable.

Chat with Images

Let's consider a standard chat interface where a user uploads an image or possibly even multiple images across the conversation.

I generated this test image in multiple variations and it is surprisingly tricky for most models to get everything right.

In a standard LLM chat app, the system relies on a sliding context window. To answer the second question, the model must either rely on a highly compressed, emergent internal representation of the image from the first pass, or it must re-encode the entire image alongside the growing chat history. It is treating the conversation as a "next token prediction" problem, while hoping that critical image detail was captured in its internal attention weights.

The same conversation in my blackboard UI - note the journaled image "Q&A".

Speech Acts on a Blackboard

A coding agent treats the chat (operator messages), its own responses and tool outputs as an event stream from which a BDI is parsed and used to derive its internal state, which is (usually) explicitly represented. The anti-pattern part here, which still remains, is the limited context window which accumulates the chat transcript. That would be a redundant non-issue in an ideal case, where all incoming inputs are fully represented in the internal state, which is unfortunately not the case.

Today's coding agents/harnesses are therefore only boosting the emergent model capabilities when it comes to world representation, not replacing it. They use tools, a large context window and clever internal logic to hide the inherent limitation.
Ever had an agent forget something it was asked to do?

Once we map the chat or agentic use case to an event-driven, CQRS architecture, we are no longer dealing with RPCs masquerading as agent performatives. The performatives act as state mutations of the world model itself. The Vision Reader KS asks the image targeted questions, and the answers become durable evidence on the board. No re-encoding, no context truncation, no attention decay.

The diagram above shows a board projection using just 2 knowledge sources: Vision Reader KS (priority 90) and Chat Responder (priority 80). Blue nodes are operator messages, green nodes are placed by the Chat Responder. Beige is the image evidence and purple are question/answer pairs related to the image.

The diagram above adds an additional KS: Intent Spotter (priority 95). Intent nodes are colored light red. It is no longer the Chat Responder's task to reason about the "what should be done?" part. Chat Responder simply takes the evidence produced on the board and formulates a response for the user.

The roster maps naturally onto both the classic cognitive-role split (Recognition → Planning → Execution → Reflection) and Boyd's OODA loop - Observe, Orient, Decide, Act [7]:

Role	OODA	KS in this article	Speech act	Board evidence
Recognition	Observe	Vision Reader (priority 90)	Representatives	Facts, image answers.
Recognition	Orient	Intent Spotter (priority 95)	Directives	Intent node extracted from natural language.
Planning	Decide	Planner (Chat Responder, merged with execution in this case)	Commissives	A commitment to act, journaled before any action.
Execution	Act	Chat Responder (priority 80)	Representatives, Declarations	The action performed exactly once, result recorded.
Reflection	returns to "Observe"	done by the user	Directives	Difference between intended and achieved state, posted as a fresh intent.

The hidden discrepancy between chat models and blackboard systems becomes obvious when we look at state persistence. Anyone who has used an LLM for complex coding tasks has experienced the model "forgetting" a constraint or an instruction from several prompts ago. This happens because the model's intent recognition is tied to its attention mechanism. The attention of each LLM is diluted with growing context (the "lost in the middle" phenomenon [8]).

In a Blackboard CQRS architecture, an intent is an immutable event in a log. When a Knowledge Source posts a Directive or Commissive to the board, it remains there as an unresolved node. It cannot be forgotten by a sliding window. It sits in the event store until any KS posts a corresponding result that satisfies it.

If execution fails, there could be a "Reflection" KS to close the OODA loop. It observes the discrepancy between intended and achieved state and could post a new intent to simply try again. The LLM is relegated to what it does best: acting as the cognitive engine for individual Knowledge Sources, rather than being forced to act as the entire "database", "router" and state machine all at once.

Conclusion

One more benefit comes as a bonus with this architecture: it makes any LLM better at attention. A firing KS never sees the whole transcript, only a focused projection. The CQRS read model rendered for its narrow specialization and a single task. The context stays small not because it was truncated, but because it was projected. Nothing competes for attention that does not belong to the task. The "lost in the middle" problem is avoided.

Chat remains what it always should have been: an interface. Underneath, every message is a speech act journaled as an event. Every intent becomes an unresolved node that cannot be forgotten.

Does your agent still keep its world model in the transcript? Leave me a comment below!

References

1. J. L. Austin, How to Do Things with Words, Oxford: Clarendon Press, 1962.
2. Allen Newell, "Some Problems of Basic Organization in Problem-Solving Programs", in Yovits, Jacobi & Goldstein (eds.), Conference on Self-Organizing Systems, Spartan Books, 1962.
3. John R. Searle, "A Taxonomy of Illocutionary Acts", in K. Gunderson (ed.), Language, Mind, and Knowledge, University of Minnesota Press, 1975.
4. Tim Finin, Richard Fritzson, Don McKay, Robin McEntire, "KQML as an Agent Communication Language", Proceedings of the Third International Conference on Information and Knowledge Management (CIKM '94), 1994.
5. Foundation for Intelligent Physical Agents, FIPA 97 Specification Part 2: Agent Communication Language, 1997.
6. Qingyun Wu et al., "AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation", arXiv:2308.08155, 2023.
7. John R. Boyd, A Discourse on Winning and Losing, unpublished briefing, 1987.
8. Nelson F. Liu et al., "Lost in the Middle: How Language Models Use Long Contexts", Transactions of the Association for Computational Linguistics, 12, 2024.