If Plato had notebookLM

Dialogue is not a stylistic choice. It is the information-theoretically optimal way to transmit hard ideas between two minds.

A lecture is open-loop: the speaker decides what to send before learning what the listener actually needs. A conversation is closed-loop: each utterance both transmits content and reveals what the other person currently cares about, so the next utterance can adapt. Under common priors, truthful Bayesian updating, and private — possibly shifting — relevance states, the optimal information-exchange protocol is interactive conversation. Lecture only ties it in degenerate cases where the listener’s relevance state is already known or bandwidth is unlimited.

This is why Plato wrote dialogues, why Kant is hard to read, why the Bhagavad Gita is a conversation, and why reading a paper with NotebookLM in ten minutes feels saner than reading it line-by-line in four hours.

The rest of this essay is the long version of that claim.

Most of Plato’s surviving works are written as dialogues. The Republic is a conversation among Socrates, Polemarchus, Thrasymachus, and Plato’s own brothers Glaucon and Adeimantus. Polemarchus asks what justice is; Socrates answers; Glaucon points out a fault; they correct it and move forward.

This is the beginning of Book I:

Why did Plato choose this fictional scenario? He could have written a treatise asserting his definition of justice, full stop. The treatise was the default form of written philosophy then, as it largely is now. So what made him move against the grain?

Plato was not coy about it. In the Seventh Letter he writes:

That is not a stylistic confession. It is an epistemological claim: the kind of understanding he cared about cannot be packaged into static prose at all.

Will Durant put the contrast cleanly. In his introduction to Kant in The Story of Philosophy he warns the reader, “Kant is the last person in the world whom we should read on Kant” — and elsewhere calls Plato one of the easiest philosophers to read. Compare these two passages.

A passage from each — first Plato, then Kant.

Plato writes definitions being proposed, challenged, revised, and sometimes overturned. Kant gives the finished structure of the thought, already organised and compressed. Even when the underlying idea is equally profound, the experience of reading is different. With Plato, you are present at the making of the argument. With Kant, you arrive after the argument has already been made and have to reconstruct the path backward from the conclusion.

And it is not only Greek. The Bhagavad Gita is a dialogue too, Krishna walks Arjuna through dharma, karma, and virtue not by handing him conclusions but by answering his questions and letting him ask the next one.

What difference does the form make to the philosopher writing, and to the reader trying to understand? Does dialogue help us see philosophy as inquiry, while the treatise presents it as a finished system? Are some subjects better explored through hesitation and correction, while others are suited to a well-defined structure? If Plato and Kant are both writing about justice, knowledge, virtue, and the good life, why do they sound as if they belong to different intellectual worlds?

Anyone who has read either will share the feeling I am describing.

I started thinking rigorously about why dialogue feels more natural than book-or-lecture while using NotebookLM.

I was reading a technical paper. With notebookLM, I understood what the paper was about, the approach it presented, and the context it sat in within ten minutes. With my older line-by-line approach, the same understanding would have taken four hours.

Before LLMs, I had no way to interact with a book dynamically. I had to skim it myself: which section covered what, which sections to read for the high-level overview, which parts mattered most to the main idea, what context the authors were writing in. That alone took hours. Only then could I start making sense of the technical content.

Now I can converse with a book. I can take Kant and question him back on his definitions and walk myself through the process of arriving there, the way Glaucon questioned Socrates.

That is when the older puzzle became sharp again. Plato chose the dialogue form deliberately. The Gita used it. NotebookLM had just made me prefer it for technical papers. The form was not incidental. There must be a reason.

These two papers defines conversations in mathematical form: [1] and [2]. The second strengthens the classical “two rational agents cannot agree to disagree” result and shows that they not only agree but reach agreement in a finite number of steps.

Here is the picture I want to formalise.

Talking is one agent transmitting some information and receiving some, driven by an internal motive, curiosity, a decision to make oneself aware of quantum mechanics, to make money, to find a partner, to make friends, to have fun. Restrict attention to the subset of conversations where the agents are exchanging information about a topic: a lecture, a debate with a friend on Iran vs. Israel, a group discussion on RCB vs. GT. This is the setup researchers already use. Two or more agents communicate, and the goal of optimal information transmission is the same as optimising entropy reduction. The more entropy each side reduces about the topic, the better the conversation went.

But there is a hidden state: what each agent currently wants to know. We have no clean way to transmit this directly, and it can drift as the conversation flows. You start a debate over whether Trump is a good person; the other person mentions a story they read in the paper; suddenly you are curious about his teenage years, and so are they. The target keeps moving, and tracking that target is part of what we do while conversing.

In a conversation you emit a small chunk of information, receive a small chunk, and repeat. Each emission does two jobs at once:

1. it transmits content that reduces the other person’s entropy about the topic
2. it reveals something about your own hidden goal, so the other person updates their estimate of what you are trying to understand

The conversational form makes sure these two jobs happen hand in hand. A lecture cannot. A lecturer does not estimate the listener’s hidden state at all; they decide what to send before knowing what the listener needs. Most of the time the listener does not even know what is coming, and so has not built the gap where the new information could fit. (This is why professors advise prior reading and coming with questions: questions are the gaps that get filled. With no gap, there is nowhere for the information to sit, and it bounces off.)

Lecturing ten people is trying to estimate the hidden state of ten different listeners, take an average, and transmit toward the average. The averaging is hopeless. Sitting in a debate with eight people who are also trying to talk to you is worse, eight hidden variables to track on your side, eight on theirs, all updating in parallel. This never works, and everyone who has been in such a debate knows it. Debates are not really about transmitting information.

Here is a tighter version of the argument that is easier to build on.

This is an original synthesis on top of the common-prior setup used by Aumann [3] and Aaronson [2], extended with a hidden variable for relevance: what each person currently wants to know.

Let the world be:

Ω = Θ × Z_A × Z_B

where:

• Θ is the factual state of the topic.
• Z_A is A’s hidden relevance state.
• Z_B is B’s hidden relevance state.

For example, Θ may contain facts about Trump, while Z_B might mean: “right now I care about his teenage years.”

Let D be a common prior over Ω.

Each agent i ∈ {A, B} observes:

• a private signal S_i = s_i(ω) about Θ
• its own hidden goal Z_i

After a transcript h_t = (m_1, …, m_t), agent i’s information cell is:

Ω_{i,t}(ω) = {ω' : S_i(ω') = S_i(ω), Z_i(ω') = Z_i(ω), h_t(ω') = h_t(ω)}

and the posterior is:

μ_{i,t}(ω') = D(ω' | Ω_{i,t}(ω))

Now define, for each possible hidden goal z, a question map:

g_z : Θ → Y_z

This means: if your current relevance state is z, then the thing you actually want to know is Y = g_z(Θ).

So agent i’s relevant uncertainty at time t is:

H(g_{Z_i}(Θ) | μ_{i,t})

and its uncertainty about the other person’s hidden goal is:

H(Z_j | μ_{i,t}), where j ≠ i

A good conversation should do two things at once:

• reduce the other person’s uncertainty about the subject they care about
• reveal what you yourself are trying to understand

So let the welfare of a protocol π over T turns be:

W(π) = E_π [ Σ_i ( H(g_{Z_i}(Θ) | μ_{i,0}) − H(g_{Z_i}(Θ) | μ_{i,T}) ) + β Σ_i ( H(Z_j | μ_{i,0}) − H(Z_j | μ_{i,T}) ) − λ Σ_t c(m_t) ]

Here:

• the first term measures reduction in task-relevant uncertainty
• the second term measures reduction in uncertainty about what the other person wants
• c(m_t) is the cost of message m_t
• β, λ > 0 are weights

Suppose A speaks at turn t. Then a good message should maximise:

I(g_{Z_B}(Θ); M_t | h_{t-1}) + β I(Z_A; M_t | h_{t-1}) − λ c(M_t)

That is the formal version of the intuition that each utterance does two jobs:

• it helps the other person learn what they care about
• it helps them infer what you care about

This is exactly why conversation feels different from lecture.

A lecture is open-loop. A conversation is closed-loop.

Let:

• Π_lec be the set of one-way protocols
• Π_conv be the set of interactive protocols

Then:

Π_lec ⊆ Π_conv

so:

sup_{π ∈ Π_conv} W(π) ≥ sup_{π ∈ Π_lec} W(π)

In other words, conversation is always at least as good as lecture under this objective, because conversation can imitate a lecture, while a lecture cannot adapt to replies.

The more interesting question is when conversation is strictly better.

Let:

Θ = (Θ_1, …, Θ_K)

where each Θ_k is an independent fair bit. Assume:

• A knows all K bits
• B knows none
• Z_B ~ Unif{1, …, K}
• B only cares about Y_B = Θ_{Z_B}
• total communication budget is T = ⌈log_2 K⌉ + 1

In a lecture, A must choose what to send before learning what B cares about. With budget T, A can cover at most T coordinates, so the probability of sending the one B needs is at most T / K. The expected entropy reduction for B is therefore at most T / K bits.

In a conversation, B first uses ⌈log_2 K⌉ bits to reveal Z_B, and A then uses one bit to send Θ_{Z_B}. B’s final entropy about the thing B cares about falls to zero, and the entropy reduction is exactly 1 bit.

So whenever K > T:

1 > T / K

and conversation is strictly better than lecture.

Cleanly stated:

If the listener’s relevance state is private and communication bandwidth is limited, interactive conversation strictly dominates one-way transmission.

We can also model changing curiosity. Let the hidden goal evolve as:

Z_{i,t+1} ~ K_i(· | Z_{i,t}, M_t, Θ)

so the hidden state is:

X_t = (Θ, Z_{A,t}, Z_{B,t})

This is closer to real life. A conversation does not just answer questions; it changes which questions feel important. One story can make a new gap appear in the listener’s mind, and the target of entropy reduction moves with it.

The strongest safe version of the claim is therefore:

Under common priors, truthful Bayesian updating, private and possibly changing relevance states, and limited message capacity, the Bayes-optimal information-exchange protocol is interactive conversation. Lecture becomes optimal only in degenerate cases where the listener’s relevance state is already known or bandwidth is large enough to cover all relevant subtopics.

This is the formal version of what Plato seems to have known about justice, what the Gita seems to have known about dharma, and what any reader who has tried to read Kant has felt for themselves. A treatise is a lecture in book form. It assumes the reader’s Z is fixed and known, and that the bandwidth — the entire book — is enough to cover every direction the reader might want to go. Both assumptions fail in practice, which is why Kant is hard and dialogues are not.

I want to build a system of two talking agents and show that conversation is the best way for them to update information about an external subject T.

A professor can lecture, but most of what they transmit will be something the agent did not want to know at the moment it was delivered. Let the agent get curious. Let it see where its own gap is, ask the question that fills it, receive the information, and update. That is the closed-loop part. That is the part the math says is strictly better.