Description
Agentforce introduces unique challenges teams have to manage. See how Gearset’s DevOps platform helps overcome these obstacles to power faster, repeatable agent delivery without disrupting production.
Speaker:
Dave Rant, Development Team Lead
Transcript
Hello, everyone. Thanks for tuning into this session where we're going to explore why DevOps is the keystone to your agent force strategy. It's great to be here with you today.
My name's Dave, and I'm one of our agent force engineering leads here at Gearset.
At Gearset, our mission hasn't changed since day one. What we're all about is giving Salesforce teams the tools to move quickly and stay secure.
I've been at Gearset for about five years now, and as we've grown, I've come to believe this company is ultimately a reflection of its founding team, their ethos, and their principles.
Gearset's founders were a group of software engineers and product people who were genuinely passionate about DevOps, and that passion is what sparked the company in the first place.
Before starting Gearset, that founding team worked at a company building a DevOps solution for the Microsoft ecosystem.
When they became Salesforce customers themselves, they saw firsthand that DevOps could directly address many of the challenges teams are struggling with, challenges that were stopping them from realizing the full value of their Salesforce investments.
Salesforce was the platform of choice for some of the world's most ambitious businesses, but the way they built software and the tools they used left a lot to be desired.
Teams were moving at snail's pace, deployments kept breaking, and frustrations grew because they weren't able to do the thing they love to do, build great solutions for their users.
They found that everyone they spoke to, just every single team, was telling the same story.
The platform is incredibly powerful, but managing change becomes ever more difficult as you grow and your releases become ever more complex.
So Gearset took a customer first product led approach and just started building small slice after small slice. We started off with a simple way to compare Salesforce environments, and over the last ten years, that's grown into a full DevOps platform.
Now we've got all the things you'd expect, continuous integration and continuous delivery backed up by pipelines, backup and restore so you've got data security, code reviews so you get static code analysis, observability, org intelligence so I can understand what changes I need to make in my orgs, and robotic regression testing.
And sitting atop all of this is an awesome agent that is helping you get the best from it.
And the company's grown too. We're now a team of three hundred and fifty talented folks, and what I love is that even as we scaled the product first, customer first mindset hasn't changed. We live and breathe DevOps.
We're pushing to production two or three times a day every single day for our customers.
Talking to customers has been part of Gearset since day one, and we've also got an incredible team who are out there talking to customers all day.
We want to understand the challenges teams are facing, so we build the right solution and ship it as soon as possible.
And in doing that, we've now got more than three thousand teams relying on Gearset across every segment, and this scales from teams of ten contributors through to teams with hundreds of developers and admins, from tech to government and everything in between.
What happens next in the Salesforce ecosystem really matters to us and to every one of those teams we work with because when the ground shifts under the platform, the way we build has to shift too.
When Salesforce released Agent Force, we sat up and paid attention.
We've been in this ecosystem for over ten years, and there's been lots of different things that have come along in that time. But this one really feels different.
This isn't just another feature. It's a leap.
It's not just a leap for Salesforce, but it's a leap for our industry.
Our industry only goes through these big shifts, I think, once a decade.
Google changed how we use search. Apple changed how we used our phones, and now AI is changing how we interact with technology.
And here's the thing, three years ago, this stuff just didn't exist.
So now we've got LLMs that can take in huge datasets, understand the context, and ultimately make decisions.
They don't just follow a set of prewritten templates, and this is the thing that's so exciting. They can generate something completely new, unique every time that's contextual for every user and every query. So it's equally cool as it is scary.
With Agentforce, Salesforce is embracing this paradigm shift, and it's going to change the way we build and deliver on the platform.
Salesforce themselves have described it as the future of the platform, And when you look at the scale of it, it's ambitious and exciting, mainly because it unlocks a new way of working.
And this isn't just about one part of Salesforce. If you work with Sales Cloud, Agent Force changes that. If you work with Service Cloud, it changes that too.
Agent Force touches every cloud and every app. This isn't a separate thing you have to learn. It's woven into the platform itself.
It's going to change how you build everywhere.
If that's customizing one of their clouds or building something brand new, Agent Force is going to have a role to play.
Yes. It's exciting and it's energizing. Yes. It's disruptive and yes. It's challenging and, yes, it's still relatively in its infancy with some great problems for us to go and solve as an ecosystem.
And as the industry goes through these paradigm shifts, this once a decade leap, every leap forward comes with obstacles. And the bigger the leap, the more urgent it becomes to tackle those obstacles head on. And this leap is possibly the biggest we've experienced yet.
We've seen plenty of Salesforce releases over the years. So what is it about agent force that's more challenging?
Well, it's not predictable.
Call me old fashioned, but I'm used to traditional development where you write the code, you run the code, you get the results you expect, and you run the code a thousand times, you'll get the same result each time, and then you move on.
But agentic systems don't behave that way.
The same input can give you a different output each time. That's powerful, but also unsettling because that's not how we've come to think about how computers work.
How do you even begin to test and trust and verify that at scale?
These systems run on data models and prompts that keep shifting, and even the models themselves get updated. That means agent behavior can change in ways you don't see coming.
You might have heard the term observability, and we won't go too far into it right now, but it's an essential part of how you debug, stay compliant, meet government's requirements, and most importantly, keep trust with your users.
Has always been the lifeblood of our processes, and a big part of our jobs has been keeping it clean and reliable so we, as humans, can make good decisions based on that data.
But with Agent Force, that importance is dialed up to eleven.
Agents don't just rely on good data. They're powered by it. You put garbage in, you're gonna get garbage out. Bad inconsistent data that's all over the place because you haven't needed to think about this rigor until now.
It will break your agents, whether that's in a testing environment or in production.
Testing is really interesting. If teams want to move fast, testing can't be bolted on at the end. It has to be introduced early in the development life cycle.
You might have heard the term shifting left, and that's what we're talking about here. Moving your testing and validating to much earlier so there are no surprises later on.
Think about how you test today. Maybe you run a flow or some Apex against a small dataset just to see how it behaves.
Well, with AgentForce, that's not enough. That's insufficient nowadays.
What feels like a realistic amount of data won't be anywhere near enough for agents by orders of magnitude. They need big representative datasets if you want them to behave reliably in production, and that means the way we think about testing has to shift too.
And this discontinuity isn't just about technology, it's about the people too and these things always are.
It changes what it means to be an admin, what your team is responsible for, and how you work together. And with the platform shift this big, you're not going to get there just by reading a few docs or release notes. This is going to change how teams work day to day.
Think about what it meant to be a Salesforce admin even a few years ago.
I think we'll look back at this moment as one of those big changes.
There are going to be new techniques to learn, new practices to adopt, and the old ways just won't cut it anymore.
And here's the other thing, the rate of innovation has been accelerating for a while now, but with agent force, it's astounding how quickly things are moving faster than anything we've seen before.
And so this is why I talk about agent forces more than just another release. It's a step change.
Salesforce has put together something they call the agentic maturity model, and it's actually a really helpful way of thinking about how teams will adopt agent force over time.
At level zero, you've got the stuff we all know, rule based workflows, scripted FAQ replies, those basic automations we've all used before. Super handy, but pretty limited.
Level one is for your information retrieval agents. They understand intent and can give you an answer based on data pulled from Salesforce or a knowledge base like Data Cloud, but they still need a human to decide what to do with that information.
Level two is where it starts to get interesting. This is where agents can actually take action but just within a single domain. So they might go ahead and create a case, book a service, or schedule an appointment for you.
And then at level three, it gets even more powerful.
Agents can now coordinate across multiple workflows. So think about rebooking a flight. At level three, an agent can also update your hotel, send an invoice, and arrange your Uber all in one flow.
And finally, level four is where Salesforce talks about multi agent orchestration.
That's where you've got multiple specialized agents working together, almost like a team of digital colleagues to complete complex cross functional processes.
It sounds pretty amazing. Right?
Well, the reality is that most teams are still sitting at level one, and that's okay. That's kind of what we expect with something this new, but there are other reasons why teams aren't at level four.
You want the agent to do the exact actions you want, but you don't quite trust the agents to take those actions on their own. Why?
What's holding you back from that trust? Because the data is not always clean, the pipelines aren't fully in place, there's a lack of confidence in your testing.
Teams really want to move up this curve, but they are hitting the same blockers, and this is where DevOps can help.
DevOps is what clears those blockers. It's what gives you the repeatable process, the clean data, the speed to iterate, and the observability.
The confidence you need to let the agent take that action and climb to the next level.
When we think about knocking down those blockers, a lot of people mistake DevOps as being just about releases, but it's really about working across the whole software development life cycle.
And we can use the familiar Infinity Swirl to visualize this.
So we can apply these processes to AgentForce where we want to deliver changes repeatably and reliably.
These systems are dynamic.
They're data hungry, and they change fast.
If we want to keep up, we need to build and ship with confidence.
Looking at the life cycle, we need to understand the state of our orgs, build the right changes, catch issues early, release frequently, and respond quickly when things go wrong.
This is Gearset's wheelhouse. We've done it for years with all sorts of metadata, and now we have this repeatable, reliable process to get your agents into production safely and to keep them there as they learn and improve over time.
Let's break it down and show you gear set at each stage of this life cycle.
So how do you get going?
Before you build an agent, you've got to understand what already exists in your org. What data do you already have? What's missing? What metadata does this agent need to touch?
This is where Gearset's org intelligence is a game changer. It scans everything in your org and gives you the blueprint of the complete org architecture.
Without this, you'd spend hours manually digging around, trying to piece things together with a handful of different tools.
Org intelligence remove the guesswork and gives you the complete picture, even in an org you don't know or one that's been through years of changes.
Then you build your agent, and here, Gearset helps you work safely.
This is one of our newest features which allows you to track and commit any Salesforce changes right there in your browser.
The extension gives you real time visibility over every change. And because those changes are version controlled from the start, you've got a complete history to fall back on, which means fewer mistakes and a smoother path to production.
Now we come to validation. This is a really important step, and I'm not going to get into all the ways that agent force can expose new data exfiltration factors, but there's a whole bunch of new threats that come with this level of opportunity that AgentForce brings.
But at Gearset, we have code reviews, which catches issues early so you can fix them before they reach production.
The scans analyse every change against best practices and the well architected framework to catch vulnerabilities, flag bottlenecks, and enforce standards for high quality code.
When you're ready and all your checks are green, it's time to release your agent into production.
Gearset makes deploying your agents into production very easy. With a CICD pipeline, that release isn't a leap of faith.
It's a controlled, repeatable process.
Gearset Pipelines gives you a clear view of your entire release flow, every change, every org, all in one place.
You can manage approvals, promote changes step by step, and see exactly where a release is held up.
And as we make our way around the life cycle, we come back to automated backup and restore where you can clearly see any unusual activity in your org and recover quickly if something goes wrong, whether it's bad data, a rogue change, or an agent behaving in a way you didn't expect.
And when something goes wrong, you can choose your preferred restoration workflow, making sure that no dependencies are left behind.
And archiving becomes critical, especially for agents.
Creating policies that clear out old or unused records keep your orgs lean, so your agents are only working with the most relevant high quality data.
That means better decisions, fewer weird edge cases, and a smoother experience for your users.
And if you ever need that data back, you can just bring it back in in just a few clicks.
Creating policies is easy and can be done in a matter of seconds as you're seeing on the screen.
Once the agent is live, you've got to keep it steady. Gearset's observability solution surfaces every flow and apex failure across your orgs, all your org limits, and pulls them all into one place.
Instead of trawling through logs or waiting for end users to tell you something's broken, you see the problems first and the patterns behind them.
With agents where behavior shifts as data and prompts change, that kind of visibility isn't just nice to have. It's essential.
And then the next stage encompasses everything. You iterate because agent force agents learn and evolve and so should you, your team, and your process. What works and what doesn't?
I hope what I've shown you today is that some parts of the playbook are familiar, but some of this is completely new and that a lot of agent force is still unknown.
We don't yet know everything we're going to be able to achieve over the next few years as an ecosystem.
If you're excited about that, brilliant. If you think I'm talking nonsense, then even better. We'd love to chat to you.
This ecosystem has always been collaborative, and that's what makes it great, so let's keep talking. Get in touch with us, share your stories, your wins, your headaches, and let's figure out the next wave of solutions together.
