How to Use the Support Agent in GetGenerative.ai: A Step-by-Step Guide

The Support Agent in GetGenerative.ai revolutionizes how organizations deliver managed services after implementation. It automates the resolution of support tickets by analyzing the project’s history, linked metadata, documentation, and codebase — enabling faster, consistent, and AI-driven support.

This agent is tightly integrated with your Salesforce implementation lifecycle and works best when your org has used Pre-Sales, Design, Build, and Test Agents.

Key Functions 

• Accepts and processes 4 ticket types:
  • Bug
  • Enhancement
  • Change Request
  • New Feature Request
• Auto-generates:
  • User stories with acceptance criteria
  • High-level and low-level solutions
  • Implementation workbook
  • Test cases
• AI-powered resolution based on:
  • Project documentation
  • Configuration workbook
  • Metadata and codebase
  • Design/Build Agent outputs
• Enables chat-based resolution search across:
  • Metadata
  • Code files
  • Uploaded documentation

Getting Started with the Support Agent

The Support Agent is designed to streamline post-implementation support. To begin using it, you’ll need to either create a new support project or link it to an existing project that was handled by the Design Agent or Build Agent.

Step 1: Navigate to the Support Agent

From the left sidebar, click on Support Agent.

Step 2: Start a New Project

Click the Start New Project with AI button on the top right of your screen.

Step 3: Choose How to Start

You’ll be prompted to choose how to create your support project:

• Create New Support Project – start from scratch.
• Start from an existing Design Agent – use prior design data to raise support tickets.
• Start from an existing Build Agent – reuse implementation assets to address new support issues.

In most cases, it’s recommended to start from an existing Design or Build Agent project to leverage previous context, configurations, and metadata. This ensures accurate ticket resolution and better lifecycle continuity.

Here, we select one from the list of existing Design Agents. 

Support Project Dashboard Overview

The Support Agent dashboard includes a summary of all ongoing support activity:

• Open Tickets
• Closed Tickets
• Time Saved (via automation)

This workspace is specifically optimized for managing support tickets within the context of your existing Salesforce implementation.

You’ll see 5 key tabs:

1. Project Brief – Provides a detailed overview of the project including scope and out-of-scope items. This serves as a foundational reference to ensure support tickets align with the original goals.
2. Tickets – This is the core focus of the Support Agent. It allows users to:
   • Raise new support tickets linked to Design or Build Agent outputs.
   • View ticket history and status (open or closed).
   • Access automated insights and recommendations from AI for quicker resolution.
   • Track time saved and outcomes per ticket.
3. Document AI – A smart document repository integrated across agents. Upload and interact with requirement docs, solution blueprints, logs, or SOWs using natural language queries.
4. Metadata – Automatically imports metadata from your connected Salesforce sandbox to provide intelligent recommendations during ticket resolution.
5. Code Base – Displays any AI-generated code snippets associated with the support tasks. This is powered by the Code Agent, your AI assistant for development and deployment tasks.

Now let’s explore the Tickets tab—where all the real action happens in the Support Agent.

Here we have created a dummy ticket you can use to fill out the “Create New Ticket” form in the Support Agent interface:

You can log a ticket manually by:

• Selecting the ticket type
• Describing the issue
• Uploading optional documents
• Assigning priority, cloud, and assignee

To begin resolving the ticket, we simply click on the “Find Resolution with AI” button. This triggers the Support Agent to automatically generate all necessary components for issue resolution, including:

✅ User Story Generation: Includes title, acceptance criteria, steps to reproduce (if applicable), and expected behavior.

✅ High-Level Solution: Describes what to change/fix, assumptions, org dependencies, key features, and expected outcomes.

✅ Low-Level Solution + Implementation Workbook: Provides detailed technical guidance for fixing the issue using:

• Configuration items
• Metadata references
• Apex or LWC components
• Cloud/module alignment

✅ Test Case Generation: Includes positive, negative, edge-case, and regression test cases mapped to the support story.

This one-click AI workflow ensures a complete, traceable, and production-ready support ticket resolution.

Ticket Detail View

Each ticket is assigned a unique Ticket ID, and you can see the following details for each ID. 

• Title
• Assignee
• Status (e.g., Open, In Progress, Closed)
• Cloud (e.g., Sales, Platform, Service)
• Priority (High, Medium, Low)
• Description 
• Created by (name) and Date

Once you click and open the ticket in the Tickets tab, here’s what you’ll see step by step:

1. Ticket Details Section

• Includes all details of the issue.
• Editable input fields for context and summary.

2. Ticket Resolution Workspace

• Tracks progress across resolution stages.
• View or add related Requirements, each linked to a user story (e.g., identifying duplicate emails).

3. High-Level Solution Suggestions

• AI-suggested modules and sub-modules like:
  • Manage Duplicate Leads
  • Set Up Web to Lead
  • Configure Autolaunched Flow

4. Low-Level Solution

• Generated flow logic using Salesforce automation.
• Includes assumptions like daily lead limits, bulk processing, and no Apex dependency.

5. Implementation Workbook

• Lists actionable components such as:
  • Flows
  • Auto Response Rules
• Descriptions of each step required for implementation.

6. Test Cases

• Pre-generated test cases (e.g., unique email validation, duplicate detection).
• Each test case includes title, type, and ID for tracking.

Metadata + Code Integration via Chat

Support Agent offers our most advanced chat functionality yet—seamlessly connected to your project context, including Design and Build Agents.

It can:

• Search your Salesforce metadata (e.g., permission sets, profiles)
• Read and interpret extracted code files (like Apex classes, batch jobs)
• Analyze uploaded documentation
• Answer contextual questions like:
  • “What profiles exist in the org?”
  • “Explain the Account Sync batch job”

This is powered by live integration with Metadata AI, Code Agent, and Document AI.

Deployment Readiness

If the resolution involves code changes:

• Developers can write or update code in the linked Code Agent
• Push changes to the Salesforce sandbox
• Follow best practices tied to the ticket

Best Practices

• Always include clear descriptions in tickets (More context = better AI output)
• Upload supporting documents (e.g., screenshots, test logs)
• Assign correct cloud/module for context-aware fixes
• Reuse past project artifacts by linking with Design/Build Agents
• Chat with metadata and code for faster root cause identification
  

FAQs

1. What ticket types are supported?

Bug, Enhancement, Change Request, New Feature Request.

2. Can I run the full resolution flow with one click?

Yes. The agent auto-generates user stories, solutions, implementation details, and test cases.

3. Does it work without the other agents?

Yes, but functionality is enhanced when linked with Design/Build Agent for better historical context.

4. Can I search metadata and code contextually?

Yes. Use the chat feature to query metadata and code files.

5. Can I deploy fixes to Salesforce sandbox?

Yes. Customizations can be written via the Code Agent and deployed.

6. Can documentation be updated automatically?

Yes. Resolution artifacts sync with original documentation for lifecycle continuity.

7. What happens if I exceed the user limit?

You’ll need to purchase additional licenses to onboard more developers or support staff.