Most developers treat Large Language Models (LLMs) like a solitary oracle. We send a prompt into the void, and we wait for the single, authoritative voice of the machine to speak back. If it answers correctly, we celebrate. If it hallucinates, we tweak the prompt and try again.

But here is a thought that has been nagging at me: True intelligence isn’t a monologue. It’s a debate.

When you solve a complex engineering problem, you don’t just “output” an answer. You simulate a conversation in your head. One part of you suggests a hacky fix (the Pragmatist), another argues for clean architecture (the Idealist), and a third points out the performance constraints (the Critic). The “solution” is the equilibrium found between these conflicting voices.

So, why are we still building AI apps that talk to themselves in a vacuum?

I. Breaking the Monolith

We are entering the era of Agentic AI, where the goal isn’t to build a better chatbot, but to architect a “society of minds.”

This workshop isn’t just about Python loops or API calls. It is about moving from being a Prompt Engineer to being a System Choreographer. We are going to explore what happens when you stop asking an LLM to “think step-by-step” and start asking distinct LLM personas to “argue it out.”
To do this, we are going back to the original masters of the trade: Socrates, Plato, and Aristotle.

II. The “Agora” on Your Laptop

We won’t be using massive, expensive cloud models for this. We are going to build this entire “Agora” (gathering place) right on your local machine using Ollama and Small Language Models (SLMs).

Why local? Because agentic loops are chatty. They require privacy, low latency, and the freedom to fail fast without burning API credits.

We will treat these agents not as functions, but as characters.

Socrates: The relentless questioner who refuses to accept assumptions.
Plato: The idealist looking for the perfect, abstract form.
Aristotle: The empiricist grounding the debate in categorization and logic.

Your job is to build the digital framework that lets them speak, listen, remember, and—crucially—disagree.

III. Who Should Come (And Why)

This workshop is designed for people who’ve already moved past “hello world” AI demos:

Software engineers building real LLM-powered systems and feeling the limits of single-agent designs.
ML and AI practitioners exploring agentic architectures and wanting deeper intuition, not just patterns.
Technical leads evaluating whether multi-agent systems are worth the complexity—and when they’re not.
Researchers and educators interested in human-inspired reasoning and how it translates into machine systems.

If you’ve ever thought “this should work better than it does,” you’re in the right room.

IV. Why This Matters Beyond the Workshop

The debate is just the scaffold.

What you’re really learning is a reusable pattern for:

Brainstorming systems where agents push ideas in different directions
Research assistants that challenge assumptions instead of reinforcing them
Tutoring systems that adapt their reasoning style to the learner
Decision-support tools where disagreement surfaces risk early

Once you understand how personas, memory, and orchestration interact, the same architecture applies everywhere.
This is not about making agents sound philosophical. It’s about making them structurally intelligent.

In this workshop, it begins with disagreement— carefully engineered, rigorously constrained, and finally, productive.

Building multi-Agent AI systems: a philosophical debate

{{ gettext('Draft') }}