Building Reliable AI Agents: From Architecture to Adoption

Salesforce is putting its future on AI Agents, and the ecosystem is feeling the disruption. While it might be tempting to dismiss this new technology as not yet ready, doing so would be a big mistake. Agents are here to stay, and understanding how to build them reliably is key to success.

So, how do you ensure your AI Agents are brand ambassadors, not a source of frustration? The answer lies in a structured approach, starting with a solid foundation before you even begin to build.

The Structure of a Salesforce Agent

To build a reliable agent, you must first understand its architecture. At the top level, you have the:

• Agent, which should be thought of as the overall user experience. Below the Agent are…
• Topics, which represent a specific “job to be done”. Inside each Topic, you have…
• Instructions and Actions. A single Agent can have one or up to 15 Topics, and a Topic can have multiple Instructions and Actions.

Think of it like hiring a new employee: you wouldn’t just tell them to do “customer success”. You would give them a detailed job description outlining specific tasks and how to perform them. The same principle applies to Agents; you need to be even more precise with your instructions.

Architecting Your Agent

The architecture you choose for your Agent is critical. The decision to have a single, all-encompassing agent or multiple specialized agents depends on the experience you want to provide to the end-user, not the tasks themselves.

For example, an events company might choose one Agent that handles everything from accommodation to sessions to FAQs. This single Agent would then have several Topics, like “How do I book travel?” and “How do I book tickets?”.

It’s important to keep Topics specific and granular, avoiding broad, high-level descriptions like “customer success”. The Agent relies on detailed, accurate descriptions of each Topic to know which one to use. A one-line description will cause confusion and lead to poor performance.

Designing your Agent

Designing an Agent is a process of programming with natural language. It’s a skill that requires you to be very specific and careful with your wording.

A helpful approach is to think about how you would instruct a new, bright employee. You would map out the key steps you want them to go through and define how a successful outcome is measured. Creating a diagram of the steps makes the process easier to discuss with stakeholders and debug when something goes wrong.

A real-world example demonstrates the need for precise instructions: an Agent built to split band gig payments made a mistake because it was instructed to “calculate the mileage” and, using its own logic, assumed this meant a round trip. The solution was to explicitly instruct the Agent to “calculate the mileage in one direction and multiply by two”.

Picking your use cases

When starting out with Agents, it’s best to pick low-risk use cases with low deployment risk. These are typically internal-facing processes with relatively low risk, such as answering questions about HR or the expenses policy.

Avoid complex, customer-facing use cases that require voice and advanced technology. The goal is to get some early, quick wins to build momentum and prove the concept.

As you become more sophisticated in your approach, you can begin to design Agents that do things a human couldn’t, like reading hundreds of pages of documents without getting bored or frustrated.

Agent readiness

While the technology for Agents is ready, not every organization is prepared for adoption. The key is not data readiness—your data will never be perfectly “ready” —but rather having a sponsor who is excited about the potential of Agents.

This isn’t a project like building a simple flow; it’s an iterative process that requires a level of trust from leadership to allow time and space for experimentation.

You should also manage expectations. Don’t promise a complex, customer-facing Agent from the start. Instead, focus on small, internal-facing use cases that are low-risk to deploy.

Foundations to make Agents work

For Agents to work effectively, an organization needs strong foundations in several key areas:

• Well-Documented Processes: If your operational processes are not well-defined or are still “in people’s heads,” it will be challenging to build a transactional Agent.
• Data Governance and Quality: While data is never perfect, you need to understand how it flows into your systems. A polluted data stream will undermine any Agent you build, no matter how clean the data is at a single point in time.
• Metadata Management: Agents will be calling flows and other metadata, and if these are not well-documented and managed, it can quickly lead to a loss of control. Imagine an employee changing a flow without realizing it’s being used by several Agents; the result could be a wrong answer provided to a customer.
• DevOps: A well-understood DevOps cycle is essential for versioning and governing Agents as they are iterated quickly in the early days. This governance builds trust among stakeholders.

The good news is that working to improve these foundations for Agents will also make your entire Salesforce implementation better.

How to get started

The final word on getting started is simple: just start. Begin with a small, internal use case, like something for your team or even for a personal project.

Building Agents is a new skill, and the best way to learn is by doing. As an Agentblazer, you need to be at the forefront of this technology, not hiding from it. The future is filled with Agents, and it’s time to start building your skills now.