Caio Pedroso

When ChatGPT showed up three years ago, the surprise was not that it was smart. It was that it talked. For the first time, software felt conversational. That shift pulled AI out of demos and into daily work.

In Brazil, it landed even harder, because we already live inside messaging. WhatsApp is where we schedule, buy, sell, solve problems, and run parts of companies. So it did not take long for “AI” to look like a bot in a chat.

From there, adoption spread fast. Support triage. Inbound qualification. Scheduling. Internal ops. Sales enablement. Then came agents, systems that could take a goal, move across tools, and complete multi step tasks. It felt like a real step forward.

And for a while, it was.

But as agents moved from demos into real work, a different pattern emerged. Not spectacular reasoning failures, but quiet, repeatable breakdowns. The kind that only appear once a system is forced to act on the same information humans have been improvising around for years.

What broke was not reasoning. It was the assumption that reasoning could compensate for weak inputs.

Agents do not fail because they think poorly. They fail because they are asked to reason on top of ambiguity, ambiguity humans have always resolved informally. And now, increasingly, they cannot.

Most of what matters never gets typed in. It lives in calls, messages, side conversations, and decisions made out loud. This is not carelessness. It is how work actually happens. The problem is that most systems were never designed to ingest reality as it unfolds.

That is where the breakdowns come from. A stale field in the CRM. Two definitions of the same metric. A meeting that never made it into any system. The same customer represented three different ways across billing, support, and analytics. The agent does exactly what it is told, but it has no way to know when the underlying truth is incomplete or inconsistent.

Humans patch over this kind of mess all day without noticing. Software cannot. And when agents are wrong, they are wrong with confidence.

I have seen teams explain failures by saying, “That field was never documented,” or “That meeting was not in the CRM, so the agent could not know,” as if the issue were the model rather than the system it was dropped into.

Over time, another pattern became clear. Agents were quickly becoming normal.

Everyone had access to the same building blocks. Tool calling. Reasoning loops. Prompts. Orchestration frameworks. Spinning up a capable WhatsApp agent was no longer hard. What mattered was what the agent walked into.

Deploy the same agent in two different companies and you get different results. Not because of randomness, but because each company defines reality differently. What qualifies as enterprise. Which system owns revenue. How churn is calculated. Which number people actually trust.

The agent is not confused. It is precise. It simply operates inside the definitions it is given.

The same thing happens inside a single company. Two people ask the same question and mean different things. One wants a headline. Another wants a drill down. One wants something they can act on immediately. Another wants every caveat. None of that lives cleanly in a schema. It is not just about facts. It is about context, habit, and everything that has already happened between the system and the person using it.

This is where most agent narratives fall apart, because they conflate two very different layers that only look similar from the surface.

At this point, it becomes tempting to treat all of this as a single problem: more context, more history, better memory. That is exactly where most agent narratives go wrong. They collapse fundamentally different concerns into one layer.

One of those layers is memory. Memory is not chat history. It is the shared state the system can safely rely on. It is where durable facts live, along with their provenance and the rules that make them usable. It resolves identity across systems, handles conflicts when records disagree, and decides which version of reality wins when they do. You can think of it as a data warehouse for agents, not because it stores data, but because it reconciles it into a version of truth the system is allowed to act on.

Memory does not replace systems of record. It sits above them. Systems of record remain the source of claims; memory is where those claims are reconciled, versioned, and made safe for execution.

This work is invisible by design. And it is why the idea that systems of record are disappearing misses the point. They are not going away. They are moving into the background.

In an agentic world, systems of record stop being products and become infrastructure. The more work you automate, the more you depend on them. Not as interfaces, but as the place where truth is defined and protected. Agents do not replace them. They force their weaknesses to surface.

Take something as simple as ARR. Sales tracks one version in the CRM. Finance calculates another in the ERP. Accounting thinks in revenue recognition. Legal reminds you that contracts are rarely clean subscriptions. Humans reconcile this informally. Agents cannot unless the rules are explicit and encoded somewhere.

Memory makes the system correct. But correctness alone does not make it valuable.

That is where personalization comes in, and this is where the real moat starts to form.

Personalization is not about facts. It is about adaptation. It is the system learning how to work with a specific person over time. What they care about. What they already know. What they tend to ignore. How much detail they want. When they prefer speed over completeness, and when they want the system to slow down and be careful.

This does not live in the same place as truth, and it should not. Memory answers what is true. Personalization governs how that truth is applied in practice, for this user, in this moment, based on everything that has happened before.

Put simply, memory changes what the system knows. Personalization changes what the system does with what it knows.

This matters even more in a world where nothing gets typed in. The same way AI can translate calls and messages into shared memory, facts that need to be reconciled and made durable, it can also translate interactions into behavioral defaults. What to repeat. What to skip. When to push. When to pause.

Those defaults shape execution, not reality. Truth still needs a home. Personalization should never quietly rewrite facts. But it absolutely should rewrite the experience.

When this works, something subtle happens. The agent stops feeling like a generic interface and starts feeling hard to replace. Not because it knows more facts than another system, but because it knows how to work with you.

You can export data. You can migrate records. What you cannot easily move is accumulated understanding. The shared language that has formed. The shortcuts the system has learned. The way it anticipates what you mean instead of making you restate it.

This is why two agents with access to the same tools can feel completely different in practice. One answers questions. The other fits into how you already work.

Many companies struggle here in a quieter way. They may have strong data infrastructure, but identity is fragmented, definitions live in people’s heads, and context is not encoded anywhere. Every new agent ends up relearning the same things from scratch. The friction does not show up in demos. It shows up in slow adoption and brittle automation.

Once agents start executing actions, this distinction becomes impossible to ignore. Workflows change state. Messages go out. Pricing gets applied. Contracts get generated. If definitions are unclear or conflicts unresolved, you do not just get a bad answer. You get a bad outcome.

That is why the defensible layer in AI is not the agent.

Agents will get cheaper and more common. Infrastructure will evolve and be replaced. What compounds is accumulated meaning. Identity graphs. Definitions. Conflict resolution rules. And, most importantly, personalization logic built from real usage over time.

That is what is hard to move.

It also reframes how I look at AI companies. If a platform has strong retention but weak AI usage, the stickiness is likely coming from the legacy product. If an AI app struggles with expansion and payback, it is probably a nice to have. The most interesting companies are the ones that adapt deeply to their users and become more valuable the longer they are used.

None of this requires replacing everything. You can start small. Fix identity. Encode definitions. Store the right history. Let personalization grow naturally from real interaction.

AI does not remove complexity. It exposes it.

Humans have long been the glue holding together fuzzy definitions and contradictory systems. Agents cannot be that glue. They need truth they can trust, memory that makes truth usable, and personalization that adapts that truth to the person on the other side of the conversation.