Winning the Agentic Era: Why We Transformed the Foundation of Agentforce

We know why enterprises succeed — and fail — with AI.

I’ve been shoulder-to-shoulder with customers from the early bot days to today, helping teams turn raw model capability into production-grade systems. Along the way, we’ve seen clear, measurable ROI from agentic AI — from Wiley increasing case resolution by 40% to Falabella autonomously resolving 60% of their WhatsApp inquiries. 

We’ve also seen promising projects stall when the gap between “impressive model” and “enterprise-ready system” gets exposed.

In parallel, the industry is experiencing a broader shift. From tools like Claude Code to notebook-driven workflows, text and conversation are becoming the default way software gets built and enterprise work gets done. This moment of rapid change, combined with the hard-won lessons from partnering with customers, has led us to three core beliefs that shape why and how we’ve transformed the Agentforce platform.

1) Models are not enough.

LLMs are an almost incomprehensible technological achievement, but intelligence alone doesn’t deliver enterprise value. Real ROI requires systems that blend rules and reasoning so agents behave reliably when stakes are high.

2) Files are where work gets done: the shared artifact where humans and AI build, together.

Even as interfaces become increasingly multimodal, text remains the most durable way to express, inspect, and govern behavior — and the format where humans and AI can collaborate most easily. LLMs work best when they can operate on clean, structured text artifacts. That’s why the unit of building in the agentic era becomes a file: a portable, versioned asset that moves beyond environment-bound configuration and can be tested, packaged, promoted, and audited like software.

3) Writing is the new building and AI is a first-class participant.

If files are the foundation, the builder experience has to follow. Writing is the new building, and that means the interface for builders has to center around writing itself. AI can’t be a bolt-on. Rather, it must be a first-class participant at every step, helping teams draft, test, debug, and iterate faster.

These three beliefs aren’t slogans or abstract philosophy. Each belief above is now realized in a specific Agentforce feature: Hybrid Reasoning, Agent Script, and the new Agentforce Builder. Let’s unpack each one in more detail.

Hybrid Reasoning: The Enterprise Needs More Than Just LLMs

LLMs excel at natural conversation, synthesis, pattern recognition, and making reasonable judgments when inputs are ambiguous. But LLMs are not magic.

Without guardrails and proper context, they don’t just fall short. They can become confidently wrong, unpredictable, and create genuine business risk. Those shortcomings have often trapped enterprise agents in the shallow end of the pool, doing simple FAQs and low-stakes work. The minute things get sensitive or complex, you have to escalate to a human.

Anthropic’s Economic Index reflects what enterprise customers already feel: Success rates fall as tasks get more complex. The question isn’t whether the model can reason effectively. The question is whether the system can execute correctly on high-stakes tasks every single time.

For enterprise agents to swim in the deep end, they need more than just the breakthrough power of LLMs. They need the ability to dynamically control the decisions the LLM makes and the context it works with. We call this system hybrid reasoning, and it’s the missing ingredient for the repeatability and control enterprises have been waiting for.

Hybrid reasoning isn’t “going back” to old-school workflows or stepping away from AI. It’s not swapping intelligence for business rules. It’s a system that surrounds reasoning with the control needed to deploy agents into real, mission-critical workflows with confidence.

In practice, hybrid reasoning is about controlling what the agent knows and is allowed to decide at every step of the interaction:

• Steer reasoning with clear steps, variables, and checkpoints (or “state”). For example, ensuring a banking agent verifies a customer’s identity before discussing account balances, so the agent follows the right path instead of winging it. 
• Shape what it knows with deliberate context, so the model sees only what it needs to make the next decision.
• Use simple, reliable logic for deterministic work (routing, validation, formatting, permissions) instead of spending model tokens where you don’t need them.
• Save the model’s reasoning for the moments where judgment actually creates value: ambiguity, trade-offs, synthesis, and natural language interaction.

This dynamic blend of rules and reasoning gives you the freedom to trust AI with more responsibility, complexity, and ultimate value.

That’s how you move from impressive models to production-grade agents.

Agent Script: The Language for Agent Behavior

Salesforce has always been a metadata-driven platform. That’s what makes enterprise-grade customization user-friendly, governable, and scalable. Agent Script makes that foundation AI-native by expressing configuration, procedural logic, and prompts in a unified text file that humans and AI build together.

In the agentic era, the “application” becomes portable, versioned text files that define behavior, constrain it with policy, and compile down into the building blocks that do real work. That file goes wherever the work goes: code reviews, tickets, repos, chat threads. You can see exactly what changed, reuse what works, share it across teams, and promote it across environments without losing fidelity. It matches the lifecycle enterprises actually run on.

Text files also sit at the intersection of human readability and AI capability. Both can read it, write it, and reason about it natively. That makes AI a first-class partner, not just a feature bolted on after the fact. When the source of truth is a file, humans and AI collaborate on the same artifact: drafting behavior, generating tests, troubleshooting, and iterating, side by side.

Agent Script is how we make that real. It blends prompt engineering and business logic into a readable representation of agentic behavior that compiles to Salesforce metadata, unlocking the full power of the platform without turning your agent into a maze of scattered configurations. You go from idea to working agent faster because there’s one artifact to reason about, not twenty.

Our customers see the difference. “Agent Script is incredibly powerful,” says Scott Van Dusen at Equitable Trust. “Manipulating the flows and actions I want to have called is much more robust than the previous agent. I’m having a lot more success controlling it.”

Text makes the system legible to humans. Files make it operational for enterprises. Together, they make AI a real collaborator in how you build and run agents.

The New Agent Builder: Writing is the New Building

If text and files are the primitive of the agentic era, then writing is the new building. That requires a different kind of builder experience.

That’s why the new Agentforce Builder is intentionally document-centric. You can see your agent’s full configuration in a single view without searching across forms, pages, and sub-pages. Visual trees can help you grasp the overall workflow, but at enterprise complexity, they risk turning into node spaghetti. They can grow hard to interpret, hard to debug, and make it surprisingly hard to answer basic questions: what changed, who changed it, and why. Documents stay legible as systems grow, ensuring those questions always have clear answers.

We took inspiration from modern developer environments (IDEs), with file-tree organization and tabbed navigation, but adapted the experience so non-developers feel at home. The Canvas gives admins and citizen builders a document-like workspace with guided steps, inline helpers, and tooltips. More technical users can flip views to edit the underlying Agent Script directly with speed and precision. The two views provide different windows into the same source of truth, which means anyone can author agents with rich controls and complex logic. 

We paired this authoring experience with a reimagined testing workflow. You can simulate your agent and start with a simple, readable summary: a clean sequence of the events it took to generate a response, plus a natural-language explanation of what happened. And when you need depth, that “front door” opens into a detailed visual trace and rich logs of every step in the agent’s behavior.

You’re always one click away from the build loop — build → test → inspect → iterate. In practice, that means it’s easier than ever to:

• Write your agent’s behavior in a document
• Run it instantly
• Understand what happened and why
• Jump back to the logic, refine fast, and keep going

But it’s not just what you can build. It’s what AI can help you build.

The Builder is where the promise of humans and AI building together comes to life. We’ve embedded Agentforce directly into the authoring experience to help you create your agent. More importantly, it helps with the hardest work: debugging behavior, explaining why the agent said what it said, learning the script language, applying best practices, and iterating faster.

We’ll keep embedding every lesson we learn into that intelligence layer, which means more teams can get successful more quickly.

Making the Agentic Enterprise Real

Frontier model labs are where the intelligence is built. But our point of view, reflected in the products we’ve launched, is what it takes to make the agentic enterprise real. The following products are all GA now:

• Hybrid Reasoning: Reasoning surrounded by controls so agents can be trusted with high-value work
• Agent Script: Behavior captured in portable text files that can be reviewed, versioned, shared, and built by humans and AI alike
• Agentforce Builder: Writing-centric, AI-first authoring so teams can build and iterate at the speed the market demands

We’re building the complete enterprise platform for the agentic era, and we’re just getting started.