Many people are quick to ask for a human rep the moment a chat window opens, still haunted by frustrating or useless chatbot experiences of yore.
But a well-engineered agent often gives the right answer faster than a human could even finish typing a greeting.
At Datasite, Grant Roberson proved that when an agent follows clear logic, users stop reaching for the exit button.
Roberson is the Agentforce admin at the high-tech M&A platform where security and accuracy are non-negotiable. He relies on Agentforce to provide enterprise-grade security and automation to Datasite customers. An early adopter of Agentforce Script, this year Roberson used it to boost Datasite’s deflection rate from the low-60s to an average of 82%.
“Ever since we put in Script, we went from a low-60s case deflection rate to staying squarely in the 80s,” said Roberson. “Our lowest week of deflection was 81%; our highest was 84%.” And customers are happy with the answers. “Our agent’s customer satisfaction scores average 4.8 out of 5.”
Roberson achieved this jump by shifting his strategy. Instead of relying solely on natural language instructions, he introduced deterministic workflows that guide users toward a resolution before they can request a human agent.
The Power of a Deterministic Gate
Roberson manages the entire Agentforce build process himself. He’s an admin, not a traditional developer, and he uses a balance of tools to maintain control over the agent. He works about 50/50 between Agentforce Script and the Canvas visual builder, keeping instructions on the Canvas while managing topic logic and deterministic flows in Script. This hybrid approach allows him to define exactly how a conversation should flow.
“For writing instructions, I’m always going to be in the Canvas,” said Roberson. “If I’m adjusting something, I find that it works a little bit better in the code part because it’s easier to make granular adjustments.”
To maximize the agent’s effectiveness, Roberson used Agentforce Script to build deterministic guardrails. He implemented a specific rule in Script: the agent requires the user to pose a formal question before the “Escalate” action is triggered. This ensures the AI has enough context to attempt a resolution before a human intervenes, effectively filtering out premature handoffs.
To boost agent precision, Roberson uses conditional logic directly inside the Canvas. Using a simple conditional format to state that “if this is true, run this,” Roberson replaced long, redundant legacy instructions.
“We were able to kill off a ton of instructions that we used to have in the legacy builder,” Roberson said. “It’s a fraction of what it used to look like, and there’s so much more of a guarantee on its output.”
“I used to have paragraphs of repetitive instructions everywhere to try and force behavior, ” he explained. “With Script, it’s easy to remove that noise and replace it with conditional logic that lets you trust your agents to do exactly as you want them to.”
Validating the Conversation
To ensure this architectural strategy translated into real-world accuracy, Roberson conducted a manual audit of 400 recent conversations. The results were definitive: the agent provided a high-quality, accurate resolution in all but two instances — a massive leap from the roughly 33% failure rate seen with legacy agents.
For Roberson, the validation is found in the “joy” of predictability. “It’s probably one of the bigger joys to know that what you think is going to happen actually happened,” he said. “That’s where we are with Script. It really takes away the frustration because you know, without a shadow of a doubt, it’s going to run 100% of the time every time.”
This precision has allowed Datasite to sustain a deflection rate that averages 82% while maintaining high-quality interactions. The agent currently maintains a customer satisfaction score of 4.8 out of 5 — a metric that places its performance on par with the firm’s human support team.
Scaling the Logic
Efficiency is a core part of the Datasite workflow. Roberson treats his Scripts as modular components. He copies and reuses Script blocks between agents, trimming out the parts he doesn’t need for each new use case. This allows him to deploy new agents rapidly while maintaining a consistent logic structure across the organization.
“In a couple weeks, I’ll have every one of our non-SDR agents converted into Script,” Roberson noted. “It’s working so well that there’s no reason to stay in the legacy builder anymore.”
The Result: Precision at Scale
Since implementing Agentforce Script during its beta testing phase last year, Datasite’s shift in numbers was immediate and sustained:
- Deflection: Case deflection jumped more than 17 points to an average of 82%
- Accuracy: In a manual review of around 400 conversations, only two failed to provide a clean answer, compared to roughly 33% failing before
- Efficiency: By moving complex logic into Script, Roberson slashed his instruction count on the Canvas, leading to faster, more reliable agent responses
- Customer Satisfaction: The agent achieved a 4.8 out of 5 customer satisfaction score, matching the performance of the live support team
“I think in four weeks, we’ve done around 8,000 chats,” Roberson said. “ If you’re only passing 16-18% of those to a person, that’s saving them a ton of work. People think it’s broken, but it’s not. Agentforce is just doing good work for you.”
What’s Next for Datasite?
One year ago, Roberson and his colleague presented on a Salesforce webinar to discuss their use of Agentforce to ‘Power Front Office Operations in High Tech.’ As the sole Agentforce admin at his company and an early Agentforce adopter, he’s had a front-row seat to the tool’s evolution since then.
“Script has really simplified what we were trying to do beforehand,” said Roberson. He noted that the legacy builder often had “paragraph on paragraph on paragraph of instructions” that are no longer necessary.
Roberson is already looking toward the next evolution of his agents, focusing on converting the email agent. “I expect it to double its deflection rate once we put it in there on Monday,” he added.
Roberson’s success proves that you don’t need a team of developers to build high-performing AI. You need a clear understanding of your business process and a disciplined architectural approach. By setting clear boundaries for the user and the agent, he turned a standard support tool into a primary driver of customer efficiency.
“I just feel like it’s less problems and less time spent troubleshooting,” Roberson said. “My advice for other builders is to understand that you do have to rebuild it differently in Script than in the legacy system. Embrace it. But I can promise you it’s going to be light years better.”
Inspired to see the change for yourself? Watch demo videos and learn more about Agentforce Script here.
