Agents

Learn about SRE.ai's agentic capabilities

Overview

Agents are chat-based assistants that execute complex tasks.

Rather than navigating menus or configuring settings, users describe their needs in the chat interface, and the appropriate agent takes action.

Each agent is powered by a specialized LLM trained on Salesforce development patterns, best practices, and platform-specific constraints.

How Agents work

Activation

Agents are invoked through the chat interface based on intent.

There are no special commands or syntax. Describe what you need, and SRE.ai routes to the appropriate agent.

Examples:

• "I need to implement a regression test class for the Case Type picklist" → Design Agent

• "Let's build this" (after a design is approved) → Build Agent

• "Deploy these changes to staging" → Deploy Agent

Visibility

Agents surface every action they take.

When an agent executes, users see:

• Thought process: The agent's reasoning as it plans the work

• Plan: A structured list of steps the agent will execute

• Step-by-step progress: Each action logged with timestamps

• Artifacts: Design documents, code files, PRs, and other outputs

Users can expand any step to see details, including commands run, files read, and web searches performed.

Human-in-the-loop

Agents pause at key decision points for user input:

• Design documents require approval before building begins

• Generated code is presented for review before committing

• Deployments surface what will change before executing

This ensures users maintain control over what gets created and deployed.

Execution environment

Each agent task runs in an isolated, ephemeral container. Containers are pre-warmed, so agents start in under a second.

Every task gets a clean environment.

There is no state carried over from previous runs. This makes agent results reproducible and prevents unintended side effects between tasks.

Operations have defined time limits:

Operation	Timeout
Generate code (Apex, etc.)	5 minutes
Run code	5 minutes
Commit change	10 minutes
Review change	10 minutes
Retrieve metadata	30 minutes
Deploy metadata	2 hours

If an operation exceeds its limit, the task will fail with a timeout error.

For complex deployments or large metadata retrievals, this is the expected constraint to be aware of.

Integration with Changes

Agent work ties back to SRE.ai's Changes feature.

When an agent begins work, it creates or links to a Change artifact that tracks the full lifecycle, from design through deployment. This provides a single view of everything associated with a feature or fix.

Agents can also link to external issue trackers. If a Jira ticket is referenced, the agent associates its work with that issue. However, linked tickets are not required. Users can simply describe their requirements.

Agent summaries

Design agent

The Design Agent creates technical design documents for Salesforce development work.

What it does

Given a problem statement or feature request, the Design Agent:

• Explores your repository structure and existing patterns

• Examines relevant Salesforce metadata (objects, fields, picklists, etc.)

• Research best practices and validation requirements

• Designs a solution architecture

• Produces a comprehensive technical design document

Output

The Design Agent generates a design document that includes:

• Success criteria: What the implementation must achieve

• Architecture: Component overview and relationships

• Design decisions: Rationale for the chosen approach

• Implementation plan: Steps to build the solution

• Testing strategy: How the solution will be validated

• Risks: Potential issues and mitigations

Design documents are stored in the Change artifact. Each document has a status that tracks where it is in the review process:

You can change the status at any time using the status selector in the document header. The document content is editable and saves automatically.

Example

User: "Implement a regression test class for the value in Type picklist"

Design Agent actions:

1. Confirms the issue and creates a Change

2. Explores repository structure and patterns

3. Examines the Case object and the Type picklist metadata

4. Research picklist validation best practices

5. Designs the test architecture

6. Creates a comprehensive technical design document

7. Submits design for approval

Output: A design document specifying that the solution will use Salesforce's Schema API to dynamically retrieve and validate picklist metadata, with success criteria including 100% code coverage and immediate failure when required values are missing.

Steps

1. Describe the problem or feature in the chat interface

2. The Design Agent confirms the issue and creates a linked Change

3. Review the agent's plan via "View Plan"

4. Monitor progress as the agent researches and designs

5. Review the generated design document

6. Approve the design to proceed to building, or request revisions

Build agent

The Build Agent implements solutions based on approved designs or direct instructions.

What it does

Given an approved design or a build request, the Build Agent:

• Initializes the repository context

• Creates a feature branch from main

• Generates code files following your repository's patterns

• Creates associated metadata files

• Deploys and validates in a target instance

• Commits and pushes changes

Output

The Build Agent produces:

• Feature branch: A new branch for the implementation

• Code files: Apex classes, Lightning components, or other artifacts

• Metadata files: Associated .meta.xml files configured correctly

• Validation results: Confirmation that code deploys and tests pass

• Committed changes: Code pushed to the feature branch

All generated code follows existing repository patterns. The agent examines your codebase to match naming conventions, file organization, and coding style.

Example

User: "Let's build this" (after approving a design for a regression test class)

Build Agent actions:

1. Confirms target instance (e.g., poolorg01)

2. Implements solution per the design document

3. Creates feature branch (e.g., feature/d9c96ea9) from main

4. Creates CaseTypePicklistTest.cls file

5. Creates CaseTypePicklistTest.cls-meta.xml file

6. Deploys and validates test class

7. Commits and pushes changes

Output: A complete, validated implementation on a feature branch ready for review.

Steps

1. Approve a design document, or describe what you want built directly

2. The Build Agent confirms the target instance

3. Review the agent's plan via "View Plan"

4. Monitor progress as the agent creates and validates code

5. Review the generated files and validation results

6. Proceed to PR creation or request changes

Deploy agent

The Deploy Agent handles AI-driven deployments to target environments.

What it does

Given a deployment request, the Deploy Agent:

• Identifies what needs to be deployed

• Confirms the target environment

• Executes the deployment with appropriate validations

• Reports results and surfaces any issues

Output

The Deploy Agent produces:

• Deployment confirmation: What was deployed and where

• Validation results: Test execution and quality gate status

• Error reporting: Clear surfacing of any failures with context

Example

User: "Deploy these changes to staging"

Deploy Agent actions:

1. Identifies the changes to deploy

2. Confirms staging as the target environment

3. Executes deployment

4. Runs associated validations

5. Reports success or surfaces issues

Output: Deployed changes with validation results, logged in the Change timeline.

Steps

1. Describe what you want deployed and where

2. The Deploy Agent confirms the target and scope

3. Review the deployment plan

4. Monitor progress as the agent deploys and validates

5. Review results in the Command Center