Part 1 of 2 - The psychology, the positioning and the architecture
What if the most powerful thing an AI agent could do was not give you an answer but sit with the contradiction?
For years, we have trained machines to converge upon the answer, reduce uncertainty, and optimise. However, what cognitive science tells us is something we do not have an easy time believing; namely, that the discomfort arising from simultaneously holding two contradictory beliefs (like the example Leon Festinger referred to as cognitive dissonance back in 1957) serves as one of the most powerful engines of human reasoning.
What if we began to build that tension into the architecture of an AI agent, not as multi-agents debating back and forth between one another as separate systems but instead as structured internal conflict occurring in one mind?
This article will demonstrate how to create a cognitive dissonance agent (CDA), i.e., a single LangGraph agent who has the internal reasoning ability designed to be built upon productive self-disagreement, with measured levels of tension and architecturally enforced revision of belief. Not a committee. Not a debate club. One agent, one state, one mind- with the capacity for genuine internal conflict
The Psychology: Why Internal Conflict Makes You Smarter
Cognitive dissonance is the mental friction you feel when two of your beliefs clash. You may believe that smoking is bad for your health and at the same time have a habit of smoking. You may be a person who values honesty but has told a lie to spare someone’s feelings. That uncomfortable tension is not a bug in human cognition, it’s the mechanism that forces belief revision. Festinger’s original theory identified 3 ways people resolve dissonance:
- Change the behaviour: stop smoking.
- Change the belief: “Is smoking as bad for you as they say it is?”
- Add a new cognition: “I exercise enough to nullify the death resulting from smoking.”
The key point is that the dissonance itself is productive. Without it, beliefs are never stress-tested. We tend to live on autopilot, only seeking out information that confirms what we already think. Dissonance is the disruptor. But dissonance does not always resolve in the direction of truth. The very processes that reduce psychological tension can also produce motivated reasoning, denial of reality, or selective attention to confirming evidence. Humans generally resolve this discomfort in ways that protect their ego rather than reflect actual reality. Therefore, any attempt to create a model for AI agents that exhibits cognitive tension must account for both forms of resolution: one that is evidence-driven (i.e., corrects based upon available evidence) and the second that is self-justifying rationalization.
One Agent, One Mind: Why Is This Not a Committee?
It is simple to confuse the Cognitive Dissonance Agent with other existing concepts, but it’s actually a brand-new idea. We’re going to define the boundaries clearly: first around architecture and then against the research landscape. These distinctions are what will enable us to construct a pattern for this new concept.
It’s Not a Multi-Agent System:
If you have previously used CrewAI, AutoGen or LangGraph’s own Supervisor/Swarm libraries, you might be thinking: “I am already doing this. All I have is 3 agents set up ready to go, who just sit together and argue." That is a fundamentally different architecture.
The traditional concept is that of the multi-agent debate system (like Du et al.’s debate framework or AutoGen’s agent-to-agent messaging) to provide each agent with its own context window, its own state, and its own memory. The two agents communicate by passing messages back and forth between one another. As the individual agents are totally independent from each other, they can have an actual debate and reach agreements, representing an example of a “committee of minds” - thus, this method is a useful approach but not an example of cognitive dissonance because there is no unified self experiencing the tension.
A Cognitive Dissonance Agent is a single mind. Different perspectives: optimist, pessimist, skeptic- are all in the same graph and share the same state. They all access and modify the same working memory, and the dissonance value is an attribute of the agent’s routing mechanism.
The neuroscience model is the same: the amygdala and prefrontal cortex can “disagree” about a threat, but they are not two agents; they are subsystems of the same cognitive system processing the same information. CDA’s cognitive lenses work the same way.
It’s Not a Critic Loop:
In a critic loop pattern (generate → critique → revise), a single agent generates an output, and a critic judges it with simple feedback such as “good/bad” or a confidence level. The agent retries until it succeeds. The feedback is a single dimension of evaluation, and the system always converges, as the critic never says that a question has no clear answer.
A Cognitive Dissonance Agent is different. Multiple internal lenses generate competing perspectives, and the tension score is incorporated into the agent’s internal state, rather than a pass/fail result. The system can also indicate an unresolved conflict instead of a false resolution.
How It Differs from Research Frameworks
The Reflexion approach (Shinn et al, 2023) is a reflect-then-retry process which contains the following steps: attempting an action, evaluating it, self-reflecting, storing that reflection, and retrying the same action again. Although this process is extremely powerful, it has the potential to create “degenerative reasoning” due to the same model replicating its own logical fallacies and inherent flaws in its own reasoning. The Multi-Agent Reflexion (MAR) paper by Ozer et al. (2025) deals with this issue by employing multi-persona debate critics for better reflections. But CDA is different in that it obtains the conflict from structurally different evidence sources (through RAG) and from different nodes in the graph, instead of using one model to critique itself.
Self-Refine involves the model in loops where it is both writer and editor. Same problem, same priors for the editor and the writer.
Multi-Agent Debate (Du et al., 2023) is the closest but optimizes for consensus. But CDA specifically chooses to quantify and maintain tension. Sometimes the best answer is that views are irretrievably in conflict, and the user should be aware of this.
The Tree of Thought works to explore many options for solving a problem and then chooses the most optimal path towards having agreed upon a solution. Its main purpose is to use an exploration method to reach an agreement, and many of the non-optimal paths will be discarded once a final agreement is reached. Ours preserves all original pathways taken in the original process of seeking an alternate view.
What the Cognitive Dissonance Agent adds?
The Cognitive Dissonance Agent considers disagreement as a significant indicator, rather than only something that must be reconciled in order to find common ground. Thus, when different internal perspectives are in direct opposition to one another, the agent can provide a report on the level of disagreement rather than forcing a final answer.
An Honest Caveat:
We use “cognitive dissonance” as a design metaphor based on Festinger’s theory, not to say that the agent feels dissonance in the phenomenological sense. The architecture illustrates the functional structure of dissonance: conflicting cognitions within a cohesive state, a calibrated tension signal, and an impetus for resolution via belief revision. What it doesn’t model is the motivational aversiveness (the felt “unpleasantness”) or ego-involvement that characterises human dissonance. The metaphor is accurate enough to be helpful and honest enough not to go too far. That being said, “cognitive dissonance” is a better term here than “dialectical tension” because dialectics means two different people talking to each other, which is not what this architecture is. This is one agent arguing with itself in its own mind.
Why LangGraph: The Architecture of a Self-Doubting Mind
Cognitive dissonance needs an architecture that has a shared state, parallel reasoning, tension-based routing, and loops that can be resumed. LangGraph’s StateGraph does exactly this; it maps closely to how dissonance works.
A Single StateGraph Is a Single Mind:
We implement the agent as a single compiled StateGraph- one graph, one shared state, one mind. There is only one state that all nodes (views, analyses, reconciliations) work in. The DissonantAgentState serves as working memory, with conflicts occurring internally rather than among multiple agents.
class DissonantAgentState(TypedDict):
query: str
optimist_view: str # Internal perspective A
pessimist_view: str # Internal perspective B
skeptic_view: str # Internal perspective C
dissonance_score: float # The agent's felt tension
reconciliation: str # Self reconciliation attempt
loop_count: Annotated[int, operator.add] # Revision counter
response: str # Final output
Fan-Out as Parallel Thinking:
LangGraph has built-in support for fan-out, which means that one point can connect to multiple destination nodes through multiple edges. The graph sees this pattern and runs the destination nodes at the same time in a single “superstep”. In a superstep, all nodes run at the same time and must finish before the graph can move on.
This is a direct match for the neuroscience analogy. When you see a spider, your amygdala (which detects threats) and prefrontal cortex (which makes rational decisions) work together, not one after the other. They work on shared representations at the same time and send out conflicting signals. LangGraph’s fan-out gives us the same pattern:
# All three lenses activate concurrently in one superstep
# like parallel neural circuits evaluating the same stimulus
graph.add_edge(START, "optimist_lens")
graph.add_edge(START, "pessimist_lens")
graph.add_edge(START, "skeptic_lens")
# Explicit fan-in: all three must complete before tension measurement
graph.add_edge(
["optimist_lens", "pessimist_lens", "skeptic_lens"],
"feel_dissonance",
)
If one of the 3 lenses fails, the whole superstep fails atomically, which means there is no partial state corruption. And when checkpointing is turned on, the successful nodes in the superstep are saved. So, on failure, only the failing branch needs to run again when it resumes.
Conditional Edges as the Drive for Resolution:
According to Festinger’s theory, dissonance creates a motivational state in which the agent wants to lower the tension. In LangGraph, add_conditional_edges lets us route the graph based on any part of the agent’s state. The routing signal is the dissonance score:
graph.add_conditional_edges(
"feel_dissonance",
resolution_drive, # Routes based on dissonance_score
{
"synthesise": "synthesise",
"reconcile": "reconcile_self",
"report_tension": "report_tension",
"synthesise_with_caveats": "synthesise_with_caveats",
},
)
This is how a static tension measurement becomes a dynamic behavior: the agent’s internal conflict determines what it will do next. Low tension → put together. High tension means trying to make things right. If there is ongoing tension, be honest in your report. The graph makes this happen, and no amount of prompt engineering can get around it.
Why Some State Accumulates and Some Overwrites in Reducers?
LangGraph’s reducer system decides how to combine state updates. This is important for the dissonance pattern because different fields need different meanings:
The operator uses loop_count.add: Every time you go through the measurement node, it gives you back {“loop_count”: 1}, which adds to the total. The count goes up to 3 after three reconciliation loops, which causes the report_tension exit to happen. Without the reducer, every return would set the count to 1, and the agent would keep going in circles.
The default for dissonance_score is last-write-wins. You want the most recent reading, not a running sum. Each measurement replaces the last score, which is correct because the agent’s current level of tension is what matters for routing, not its historical average.
This asymmetry, where some fields build up and others replace, is the kind of fine-grained state control that makes the dissonance pattern work.
Checkpointing: Introspection that can be resumed:
The reconciliation loop can have between 3 and 9 LLM calls per iteration (reconciliation, three belief revisions, and re-measurement). You don’t want to run the first reconciliation and all of its belief revisions again if the second one fails because of a timeout or an API error.
LangGraph’s checkpointing saves the state at each superstep boundary. MemorySaver (for dev) or PostgresSaver (for prod) keeps the entire history of the agent’s internal conflict:
checkpointer = MemorySaver()
agent = graph.compile(checkpointer=checkpointer)
# Invoke with a thread_id to enable persistent checkpointing
result = await agent.ainvoke(
{"query": "Should we pivot to an API-first model?"},
config={"configurable": {"thread_id": "analysis-42"}}
)
You can also see the dissonance score at each iteration, how each lens changed through reconciliation, and whether the final synthesis really fixed the problem or just made it easier to deal with.
Nothe that, the state only keeps track of the current views. You can see how each lens changes over time by looking at the checkpoint history, not by looking at explicit history fields in the state.
The Full Mapping:
If you’re using this in a different framework, you need to keep these architectural features: shared mutable state across all reasoning processes, parallel execution with atomic failure, tension-driven conditional routing, accumulating loop counters with replace-semantics for scores, and persistent checkpointing.
What Comes Next: Building It
We have set up the framework by talking about cognitive dissonance, why single StateGraph works, how it’s different from multi-agent setups and how it maps to LangGraph.
Part 2: making this into code with two patterns:
Dissonant Mind: One agent with parallel RAG lenses that find conflict and either resolve it or bring it to light learning by arguing with itself.
Commitment-Disruption: One agent questions its own plan and decides to change it, explain it, or make it worse, keeping track of bias with a rationalization score.
The Cognitive Dissonance Agent: Why the Best AI Reasoning Starts With Self-Doubt was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.