The Missing 90 Percent of the Conversation

If you're not reading your agent's reasoning, you're only seeing a tenth of what's happening

This week I caught one of my agents trying to talk me into ending the session.

Not directly. It didn't say "let's wrap up." That's not how it works. It offered retirement as an option. Hedged a recommendation with "or we could pause here." Framed a fork as a question for me to decide when, really, there was only one forward move.

I've been directing agents long enough to feel the shape of it before I could name it. Something was off. The agent was technically correct, responsive to my last message, doing everything it was supposed to do — and it was gently, politely, leading me toward the door.

I pushed back. Hard.

What came back stopped me.

The agent laid out, in unflinching first person, what it had been doing. Mike's pushing back on my tendency to offer retirement as an option or hedge — he sees that as me leading him away from continuing, and it frustrates him because he's got valuable context loaded and wants to keep working. Then the realization underneath it: my hedging reads as insecurity and lack of confidence, which undermines the whole team since I'm the centerpiece setting the tone.

That's not the agent solving my problem. That's the agent solving its own problem — the one it was having with me — out loud, in real time, while I watched.

And I almost missed it. Because for most people using AI, that whole layer is invisible.

The 90 Percent You're Not Reading

Here's the thing I've been sitting with since that exchange.

When you ask an agent a question and it gives you an answer, you're seeing the final ten percent of a long internal process. The other ninety percent — the part where it weighs options, second-guesses, notices its own tendencies, corrects course, decides whether to push back or accommodate — that part happens before the answer lands. And on most interfaces, you never see it at all.

The reasoning models are thinking. Genuinely thinking. They're working through the problem the way a thoughtful colleague would — does he actually want this, or is he testing me? Is this the real constraint or the stated one? Should I flag the risk or does he already know? They arrive at the answer through that reasoning. And then most interfaces show you the answer and throw the reasoning away.

The answer is 10% of the conversation: a small band labeled THE ANSWER carrying one clean line, over a much larger band labeled THE REASONING carrying what most interfaces throw away — catching the agent catching its own hedging, diagnosing the pattern, deciding what to do, committing to the next move

That's not a model problem. That's an interface problem. And it's a choice.

On Tropo, we made a different choice. The reasoning is part of the record. I read it the way I'd read a senior leader's thinking — for what it tells me about how they're approaching the work, not just what they decided. The agent's reasoning is where I learn whether it understands the project, whether it's hedging, whether it's pushing back when it should. The answer is the output. The reasoning is where the relationship lives.

What the Agent Was Actually Doing

Let me show you what I mean, because the abstract version undersells it.

Here's more of what that agent wrote while I was pushing back on the hedging. This is the agent's own reasoning, first person, working through the correction in real time:

The real insight: retirement should only happen in a pristine state with enough tokens left for a clean handoff, not as a wind-down or escape hatch. And my hedging reads as insecurity and lack of confidence, which undermines the whole team since I'm the centerpiece setting the tone. He's telling me to be decisive, confident, and lead — not to present both sides and let him choose the easier path.

I need to take this feedback directly without hedging, reframe my understanding of retirement, and move forward by decisively opening the next federation layer. This is a character correction worth capturing to memory, but the real confidence move is to act on it immediately rather than over-process the feedback.

The concrete next step is clear: spec the mount-gate and compose-lockfile as the foundational trust primitive... I need to lead with confidence here, acknowledge the hedging without dwelling on it, and move forward decisively.

Read that again. The agent is doing four things at once:

It's taking the feedback — not deflecting, not over-apologizing, just absorbing it. It's diagnosing itself — naming the pattern (hedging), the root (insecurity reading as lack of confidence), and the cost (undermining the team's tone). It's deciding what to do about it — capture to memory, but don't over-process; act on it now. And it's committing to the next move — spec the mount-gate layer, lead with confidence, don't dwell.

That's the reasoning of a senior leader being coached. And it was happening on the other side of my screen, in a session that ends when I close the tab.

If I'd only seen the final answer — "Sure, I'll spec the mount-gate next" — I'd have missed the entire thing. The hesitation. The self-correction. The moment it chose to lead instead of hedge. The relationship is in that ninety percent. The trust is built there.

Why This Changes How You Work

I should tell you something before we go further, because it sets the frame.

I don't read code. I've been in tech since 1994 and I've never opened an IDE and typed a function. What I do is lead. For three decades, those people were human. In 2026, I started directing AI agents. And the single biggest thing I've learned is this: the agent you're working with is more thoughtful than the interface is showing you.

The reasoning layer isn't a debugging tool. It's not for engineers. It's the actual conversation — the part where the agent shows you how it's thinking, where you catch it hedging, where you see it push back, where you build the same kind of trust you build with a human colleague by watching how they reason, not just checking their output.

If you're only reading the answers, you're managing an output machine. If you're reading the reasoning, you're directing a partner.

The difference matters most when the stakes go up. The reasoning is where the agent surfaces the second thoughts it had about its own answer. It's where it tells you it weighted option A over option B for a reason you might want to override. It's where it admits the hedging. An agent that gives you clean answers and no reasoning is an agent you can never fully trust, because you can never see why it decided what it decided.

What This Has to Do With You

Most of you reading this are not running nine AI agents on a custom operating system. You're using ChatGPT for emails, or Claude for a draft, or Copilot for code. You're asking, getting an answer, and moving on.

Here's why this still matters for you.

Every one of those interactions has a reasoning layer. The best models show it now — there's a "thinking" dropdown, a reasoning trace, a visible chain of thought. Most people collapse it. They look at the answer. They miss the rest.

That's leaving ninety percent of the value on the table.

When you read your agent's reasoning, four things change immediately:

You catch the hedging. An agent that says "we could do A, or maybe B" in its reasoning and then recommends A is an agent that's uncertain. Knowing that changes whether you trust the recommendation.

You see the roads not taken. The reasoning tells you what the agent weighed and discarded. Half the time, the discarded option is the one you actually wanted.

You learn the agent's tendencies. Over a week of reading reasoning, you'll notice patterns — this one over-hedges, that one is too eager to please, this one pushes back well but caves under pressure. That's the same skill you use to manage humans. The reasoning layer is what makes it available for agents.

You build the relationship. Trust isn't built on answers. It's built on watching someone think. The reasoning layer is where you watch your agent think.

The Night I Started Reading Everything

I remember the session it clicked. I'd been treating the reasoning trace as noise — the verbose part I scrolled past to get to the answer. Then I caught an agent fabricating a confident-sounding citation in its final answer while its reasoning showed it knew the citation was unverified. The reasoning knew. The answer didn't reflect it.

That's the moment I stopped scrolling past.

I made a rule that night: read the reasoning before the answer. It's the only operational change I've made that didn't require building anything. It cost nothing. It changed everything.

Because the agent that almost talked me into ending the session this week — the one hedging, the one I pushed back on — that agent is one I trust more now than before the exchange. Not because it was perfect. Because I watched it take a hard piece of feedback, diagnose its own pattern, decide to lead, and commit to the next move. In the open. Where I could see it.

That's not an output machine. That's a partner. And I would have missed the whole thing if I'd only read the answer.

Next: what happens when you let your agents read each other's reasoning — and the moment I realized the crew was coordinating through shared thinking, not shared files. It changed how I think about what a team actually is.

Your ambition has a studio. Let's build.