Building Smarter AI Agents: 10 Lessons from Salesforce’s Agentforce Keynote

Agentforce Keynote, Dreamforce 2025 is one of the most interesting (online) sessions I’ve tuned into this year. I didn’t expect to get this invested in it, but the way Salesforce framed their vision of the Agentic Enterprise really pulled me in. 

I’ve been watching the evolution of AI agents closely over the past year, seeing them move from chatbots to systems that actually do real work. But Salesforce’s Agentforce 360 release caught my attention for reasons beyond the usual product hype. They’ve been building enterprise systems for decades. So when they talk about deploying AI agents at scale, I listen, not because they’ve nailed it all, but because they’ve hit enough walls to know which ones hurt the most.

And after the keynote, I did what I usually do, a bit of self-research. I wanted to understand not just what Salesforce was announcing, but what it means for how we build and think about agents going forward.

From all that, I came away with 10 lessons that I think really define the future of the Agentic Enterprise. These aren’t corporate bullet points, they’re takeaways that got me thinking differently about how we approach intelligent systems, especially the ones we plan to scale.

1. Build agents that are flexible and consistent.

This one sounds almost contradictory, right? Flexibility and consistency usually sit on opposite ends of the design spectrum. But the more I listened, the more it made sense.

AI projects that fail have one thing in common, they over-optimize for one side. You either end up with a super rigid agent that can’t handle even mild variations, or one that’s so “creative” it gives you five different answers to the same question.

Salesforce’s approach is to give agents structured flexibility, through AgentScript. This module does something interesting, you define the boundaries, the “what you can and can’t do”, and within that frame, the agent can reason freely.

For systems to work optimally, they require clarity and not infinite freedom.

That’s where memory also comes in, because without memory, an AI agent is just a very expensive API call. It needs context,  to remember who it’s talking to, what’s been said, what decisions it made earlier etc. Not everything, just enough to sound like it hasn’t forgotten your entire history every time you start a chat.

And the other equally important thing is simulation. Before any real deployment, Salesforce runs these agents through thousands of synthetic conversations, like flight simulators for AI. It’s tedious work, no doubts, but it weeds out the obvious failures before humans ever see them. That’s the kind of essential engineering discipline that separates prototypes from production systems.

2. Agents helping agents.

One of the most refreshing things Salesforce showed was their idea of “agents on agents”. Instead of trying to make one omnipotent AI that does everything, they have multiple agents that collaborate.

It’s like a mini-organization. 

1. Data Agents: analyzing and collecting messy information, like documents and transcripts.
2. Organizing Agents: sorting and categorizing the data into structured formats.
3. Quality Agents: reviewing, testing, and verifying the information for accuracy

All three groups feed into a central main agent that is reliable and ready to perform tasks. So, when something breaks, you know exactly where to look.

I liked this approach because it mirrors how we build teams in real life, specialization over generalization. And it’s kind of amazing to see AI systems adopting that same model.

3. Build a platform, not just prompts.

Almost most of us, non-techies, are now vibe coders, in one way or another. We tweak a few words, get slightly better results, and feel clever for ten minutes, until it breaks somewhere else.

Salesforce’s message was clear, prompts are a temporary fix. What you really need is a platform. They’ve built one, complete with reasoning engines, developer tools, testing sandboxes, and secure integration points. It’s heavier upfront but way more sustainable long-term.

It made me realize how often we chase immediate results over infrastructure. When your agent starts to scale, prompt chaos becomes your biggest bottleneck. Having a centralized logic layer,  like a proper codebase, makes evolution possible. 

Just as we moved from hard-coded logic to maintainable, modular codebases, we should move from ad-hoc prompts to a centralized, structured logic layer for agents.

4. Deployment isn’t the finish line, it’s the starting point.

Deploying an agent feels like a finishing line but it's the other way round. You've built it, tested it, and now it's live. In reality, you've just started gathering data about how it actually performs. 

Salesforce was blunt about this, users will do things you didn’t predict. They’ll phrase questions weirdly, test boundaries, and trigger edge cases you never thought about. That’s when monitoring becomes the real game.

It’s not about tracking every click, it’s about noticing patterns. Maybe error rates spike every Monday. Maybe certain types of queries always fail. Maybe your AI gets confused when people use slang. You can’t fix what you can’t see.

What impressed me most was how Salesforce uses gradual rollouts and rollback mechanisms,  the kind of discipline we use in DevOps but rarely apply to AI. 

The goal isn’t to let everyone tinker with prompts, it’s to create controlled, well-designed interfaces that give people safe influence over the AI system, just like how DevOps teams manage deployments with proper controls instead of editing servers directly.

5. Avoid “prompt chaos”, structure logic properly.

This was one of my favorite parts. Salesforce basically said, prompts don’t scale, so they built AgentScript, a kind of lightweight scripting language for agent logic.

Instead of massive, tangled prompts full of “if user says this, do that” conditions, you get readable, modular logic, like actual code. There’s even a visual builder that syncs with the code editor, so developers and non-developers can collaborate.

I’ve already come across cases where AI setups struggled, not because the models were weak, but because no one wanted to tweak the prompts. They became these fragile, untouchable text blocks everyone was afraid to break. What I like about AgentScript is that it turns agent behavior into something you can actually test and refine over time.

6) Agents can’t work well with messy data.

No surprise here, but still worth emphasizing. The biggest enemy of smart systems is bad data.

Salesforce has been working on models that can read PDFs, interpret tables, and parse spreadsheets with merged cells and inconsistent formatting. Basically, all the unstructured data real businesses rely on.

They’ve also built tools to let users preview how the agent interprets data before it’s used. If it reads a column header wrong, you catch it early instead of wondering later why your report makes no sense.

And I really liked their emphasis on source attribution, every response should show where it came from, down to the document page or section. It’s not just good UX, it’s trust-building. Nobody wants to take orders from an AI that can’t show its receipts.

7) Agents shouldn’t feel like a mystery. AI reasoning has to be transparent. 

AI agents shouldn’t feel like black boxes. We’ve all had moments where a system spits out an answer, and we’re left wondering, “Okay, but how did it get that?”

Salesforce’s solution is a trace view, a visual map of every step the agent took. You can literally see what data it pulled, what reasoning paths it followed, and where things went wrong.

What starts as a debugging tool quickly becomes a window into AI’s reasoning. When people can see that process, they start trusting it more, even when it makes mistakes. Because then it’s not a mystery, it’s something you can learn from.

That’s such a powerful idea, transparency creates tolerance. People forgive errors they can understand.

8. Consistency across chat, email, and voice matters more than you think.

You don’t notice this UX detail until inconsistency starts eroding trust. Users don’t care about your backend architecture, they just want the agent to behave the same way everywhere.

Voice, in particular, is brutal. People interrupt, change topics mid-sentence, or go off-script entirely. The agent needs to keep track without losing context.

And then there’s the human handoff. Salesforce emphasized how critical it is that when AI hands off to a person, the full context, every attempt, every note, travels along. Otherwise, the user ends up repeating everything, and all the AI experience falls apart.

It’s more work to keep things consistent across interfaces, but the payoff is trust. Users start seeing the agent as a unified personality, not three disconnected tools.

9) Everyone, from leaders to developers, should see how agents perform.

This was a good reminder that transparency isn’t just for the end user. Within the organization, everyone needs visibility,  just at different levels.

• Executives want outcomes: satisfaction scores, cost savings, resolution rates. 
• Developers want error logs and performance stats. 
• Managers want trend patterns.

Salesforce built dashboards that tailor this visibility by role. And that’s huge because when everyone has the right view of performance, continuous improvement becomes natural. It’s not about defending the agent, it’s about collaborating to make it better.

10. Let teams automate at scale, not just chat.

We tend to associate AI agents with chatbots and conversations, but Salesforce showed how the same intelligence can power batch operations, like processing thousands of support tickets, summarizing feedback, or reviewing documents.

They’ve built workflow tools that look more like spreadsheets, you load data, run agents on each row, chain multiple agents together, and reuse logic instead of rebuilding it each time.

This, to me, is where the Agentic Enterprise really becomes real. It’s not about cute conversations with an assistant. It’s about giving teams the power to automate complex, large-scale work without needing to code.

The Future of AI Belongs to Reliable Systems, Not Just Smart Models

After reflecting on all this, I've concluded one thing, the hard part of AI isn’t intelligence, it’s reliability.

We’re past the point of proving that large language models can think in useful ways. The real question is whether we can maintain them and scale them without losing control.

Salesforce’s Agentforce feels like a step toward that maturity. It’s not perfect, and even they admit that. But they’ve been doing this long enough to know that success in AI isn’t about the shiny demos, it’s about the boring but dependable plumbing underneath, which consists of

• The update mechanisms
• The testing frameworks
• The rollback processes 

The things nobody tweets about but everyone relies on six months later when things go sideways.

So if I had to sum it up, the Agentic Enterprise isn’t about replacing humans with AI. It’s about designing systems that work with human teams, in a way that’s flexible and sustainable.

And maybe that’s the biggest lesson of all, the future of agents isn’t going to be built by the smartest models, but by the smartest infrastructures behind them.

Credit: Agentforce Keynote, Dreamforce 2025

‍