Building Self-Correcting Agentic Workflows with Vertex AI

May 05, 2026

AI automations look flawless in demos but are often surprisingly “brittle” in reality. The root cause isn’t a failure of the AI’s reasoning, but a fundamental conflict between the probabilistic world of AI and the deterministic world of software.

The Challenge of Brittle AI Automations

We’ve all seen the demos: an AI agent flawlessly books a complex trip, analyzes a spreadsheet, or orchestrates a multi-step marketing campaign. It’s a compelling vision of the future of autonomous work. But when we move from the controlled environment of a demo to the chaotic reality of production, a frustrating pattern emerges. These sophisticated agents often prove to be surprisingly “brittle”—they work perfectly under ideal conditions but shatter at the slightest, unexpected deviation.

This brittleness isn’t a failure of the Large Language Model’s reasoning capabilities. Instead, it’s a failure of the overall system architecture to account for the inherent friction between the probabilistic world of AI and the deterministic world of software and APIs. The result is a system that requires constant human oversight, turning a promised [Automated Job Creation in Real Time Jobber and Google Sheets Integration from Gmail](https://votuduc.com/Automated-Job-Creation-in-Jobber-from-Gmail-p115606) into a high-maintenance tool.

Why Manual Intervention Defeats the Purpose of AI Agents

The core promise of an AI agent is autonomy. The goal is to delegate a task or an entire workflow and trust the system to handle it, navigating complexities and recovering from minor issues on its own. When an agent fails and requires a developer or operator to step in, this core promise is broken.

This creates several cascading problems:

The Scalability Ceiling: An agent that requires manual intervention for 1% of its tasks cannot be scaled to handle a million tasks. The operational cost of human oversight becomes the primary bottleneck, preventing the system from achieving its full potential.
Erosion of Trust: If users constantly see workflows stalling or failing, they lose confidence in the system. The agent is no longer perceived as a reliable assistant but as an unpredictable gadget.
The “Glorified Macro” Problem: A brittle agent that can only follow a single, perfect path is not truly intelligent. It’s merely a more complex and less reliable version of a traditional script or macro. It executes a pre-defined sequence but lacks the adaptability to be considered a true agent.

Ultimately, an agent that cannot handle exceptions on its own has not automated a workflow; it has simply shifted the burden of error handling from a machine to a human.

Identifying the Common Point of Failure: Schema Mismatches

So, where do these systems typically break? While failures can happen for many reasons, one of the most common and insidious points of failure is the schema mismatch. This occurs at the critical interface where the LLM-powered agent attempts to interact with a structured tool, such as an API or a database function.

A schema is the contract that defines the expected structure of data. It specifies field names, data types (string, integer, boolean), required vs. optional fields, and nesting. An LLM, in its conversational and non-deterministic nature, can easily violate this contract.

Consider these classic examples:

API Evolution: A weather API is updated. The field the agent was trained to use, temperature, is now temp_celsius. The agent continues to call the tool with the old parameter, resulting in an immediate error.
Data Type Confusion: The agent needs to query a user by their ID. The function expects an integer (user_id=123), but the LLM, thinking in terms of text, provides a string (user_id="123"). This triggers a TypeError deep within the tool’s code.
Hallucinated Parameters: The agent decides to be “helpful” and includes a parameter that doesn’t exist, like include_forecast_summary=True, causing the API to return a 400 Bad Request error.
Mishandling Nested JSON: A function expects a flat JSON object, but the LLM generates a nested structure, leading to a validation error.


# The tool expects this schema:

# {"location": "string", "unit": "string"}

# The LLM generates this, causing a failure:

# {"query": "weather in London", "details": {"unit": "celsius"}}

These mismatches are the Achilles’ heel of many agentic systems. They represent a fundamental impedance mismatch between the LLM’s fluid, semantic understanding and the rigid, syntactic requirements of traditional software. A simple try/except block is not enough to solve this, as it can catch the error but lacks the context to fix the underlying cause.

Introducing the Self-Correction Loop as an Architectural Pattern

To build resilient, truly autonomous agents, we must move beyond simple error handling and embrace a more robust architectural pattern: the self-correction loop.

Instead of treating an error as a terminal failure, this pattern treats it as a signal—a piece of feedback that the agent can use to learn and adapt its approach within the context of a single task. The goal is to empower the agent to diagnose its own mistakes and attempt a corrected action, much like a human would.

A self-correction loop fundamentally changes the workflow from a linear, fragile sequence to an iterative, resilient cycle:

Plan & Act: The agent decides to call a tool with a specific set of parameters based on its understanding of the task.
Observe & Validate: The system executes the tool call. Instead of crashing on an error, it catches the exception (e.g., an API error response, a Python traceback).
Reflect & Re-plan: This is the critical step. The error message, the original tool input, and the tool’s schema (its “documentation”) are fed back into the LLM. The agent is prompted to analyze the discrepancy: “You tried to call the tool with these parameters, but it failed with this error. The tool expects parameters in this format. Please correct your original tool call and try again.”
Retry: The agent generates a new, corrected set of parameters and re-executes the tool call.

This loop can repeat a few times, giving the agent multiple chances to get it right. By architecting our system this way, we transform errors from workflow-killers into learning opportunities. We build an agent that doesn’t just follow instructions but can debug its own behavior, making it dramatically more robust and truly autonomous.

Architecting the Resilient Workflow

A self-correcting system isn’t born from a single, monolithic piece of code. It emerges from the deliberate orchestration of specialized components, each playing a distinct role. The architecture’s resilience hinges on a clear separation of concerns: a powerful reasoning engine to make decisions and a reliable execution environment to carry them out. The magic happens in the communication protocol between them—a robust feedback loop that turns failures into learning opportunities.

Core Components: Building Self Correcting Agentic Workflows with Vertex AI Gemini and [AI Powered Cover Letter Automated Quote Generation and Delivery System for Jobber Engine](https://votuduc.com/AI-Powered-Cover-Letter-Automated Work Order Processing for UPS-Engine-p111092)

At the heart of our workflow are two powerful, yet complementary, Google Cloud services.

Vertex AI Gemini (The Reasoning Engine): This is the cognitive core of our agent. We leverage the advanced capabilities of the Gemini family of models (like Gemini 1.5 Pro) for more than just text generation. Its role is to understand the overarching goal, analyze the current state (including any previous errors), and determine the precise next step. Key features we exploit are:
Advanced Instruction Following: Gemini can comprehend complex, multi-step prompts that describe not only the task but also the constraints and the format of the desired output.
**Function Calling & Tool Use: We don’t ask the model to do the work directly. Instead, we provide it with a “toolbox” of available functions and ask it to generate a structured request to call one of those functions with the correct parameters.
Large Context Window: When an error occurs, the ability to feed the entire history—the initial goal, the failed attempt, and the resulting error log—back into the model is crucial for effective diagnosis and correction.
Genesis Engine AI Powered Content to Video Production Pipeline (The Execution Environment): This is the agent’s “actuator” or its hands and feet. Apps Script provides a serverless, JavaScript-based runtime that is deeply integrated with the [Automatically create new folders in Google Drive, generate templates in new folders, fill out text automatically in new files, and save info in [Automated Web Scraping with [Multilingual Text-to-Speech Tool with SocialSheet Streamline Your Social Media Posting 123](https://votuduc.com/Multilingual-Text-to-Speech-Tool-with-Google-Workspace-p809282)](https://votuduc.com/Automated-Web-Scraping-with-Google-Sheets-p292968)](https://workspace.google.com/marketplace/app/auto_create_folder_and_files/430076014869) ecosystem. It’s the perfect environment to:
Orchestrate the Workflow: The script acts as the conductor, managing the state, preparing prompts for Gemini, and parsing its responses.
Execute Tools: It contains the actual implementation of the “tools” Gemini can call. Whether it’s updating a Google Sheet, sending a formatted email via Gmail, or calling a third-party API with UrlFetchApp, Apps Script is where the action happens.
Implement Error Handling: Using standard try...catch blocks, the script can gracefully intercept runtime errors, API failures, or validation issues. This capture mechanism is the trigger for the self-correction loop.

The relationship is symbiotic: Gemini provides the intelligence to decide what to do, while Apps Script provides the secure and reliable environment to execute the decision and report back on the outcome.

High-Level Diagram: The Feedback Loop in Action

To truly understand the resilience of this architecture, we must visualize the flow of information, especially when things go wrong. This isn’t a simple linear process; it’s a cycle.


graph TD

A[Start: Trigger Event] --> B{1. Prepare Initial Prompt};

B --> C[2. Call Gemini API];

C --> D{3. Parse & Validate LLM Output};

D -- Validation OK --> E[4. Execute Action];

D -- Validation Fails --> F{6a. Capture Schema Error};

E -- Execution Success --> G[End: Success];

E -- Execution Fails --> H{6b. Capture Runtime Error};

F --> I{7. Prepare Corrective Prompt};

H --> I;

I --> C;

subgraph "[Architecting Multi Tenant AI Workflows in [Building Modular Agentic Apps Script with Gemini Function Calling](https://votuduc.com/building-modular-agentic-apps-script-with-gemini-function-calling-p-20260322917321)](https://votuduc.com/architecting-multi-tenant-ai-workflows-in-google-apps-script-p-20260321290501) (Execution)"

A

B

D

E

F

H

I

end

subgraph "Vertex AI Gemini (Reasoning)"

C

end

Let’s break down this cyclical flow:

Trigger & Initial Prompt: The workflow is initiated (e.g., a new row is added to a Google Sheet). The Apps Script gathers the necessary context and formulates a prompt for Gemini, asking it to generate a specific tool call in a structured JSON format.
Reasoning: Gemini processes the request and returns a JSON object representing the action to be taken.
Validation: The Apps Script receives the JSON. Crucially, it does not execute it immediately. It first validates the structure against a predefined schema.
Execution (Happy Path): If the JSON is valid, the script attempts to execute the requested function (e.g., call an external API). If successful, the workflow concludes.
Failure Capture (The Loop Begins): If either the validation (Step 3) or the execution (Step 4) fails, the catch block is triggered. The script captures the complete error details—the error message, a stack trace, the invalid JSON received, or the API response code.
**Re-Prompting with Context: The script now constructs a new prompt. This prompt includes all the original context plus the specific error information. It explicitly asks Gemini: “The previous attempt failed with this error: [error_details]. Analyze the failure and provide a corrected action.”
Correction & Retry: The workflow returns to Step 2. Gemini, now equipped with the knowledge of what went wrong, generates a new, hopefully corrected, JSON output. The loop continues, giving the agent one or more chances to recover from its own mistakes.

The Critical Role of Structured Output and Schema Validation

The entire self-correction mechanism would be impossibly brittle if we relied on the LLM to produce natural language instructions. The key to creating a reliable bridge between the probabilistic world of the LLM and the deterministic world of code is to enforce a strict contract.

Structured Output with JSON Mode: We explicitly instruct Gemini to respond in JSON format. Vertex AI’s Gemini models offer a JSON mode that forces the model’s entire output to be a syntactically valid JSON object. This eliminates an entire class of potential errors related to parsing malformed strings.

**Schema as a Contract: Simply getting valid JSON isn’t enough. We need the right JSON. Before writing any code, we define a rigid schema that describes the expected structure. This schema is our single source of truth.

For example, a schema for an action to update a user’s contact information might look like this:


{

"type": "object",

"properties": {

"actionName": {

"type": "string",

"enum": ["updateUserContact", "sendWelcomeEmail"]

},

"parameters": {

"type": "object",

"properties": {

"userId": { "type": "string" },

"email": { "type": "string", "format": "email" },

"phone": { "type": "string" }

},

"required": ["userId"]

}

},

"required": ["actionName", "parameters"]

}

Validation as a Guardrail: In our Apps Script code, before we ever access a property like response.parameters.userId, we use a JSON Schema validation library to check the LLM’s output against our defined schema.

If validation passes: Our code can proceed with high confidence, knowing that all required fields are present and have the expected data types.
If validation fails: This is treated as a recoverable error. The feedback sent back to Gemini is precise and actionable: “Your response failed schema validation. The property parameters was missing the required field userId.”

This combination of enforced structured output and rigorous pre-execution validation transforms the LLM from an unpredictable creative partner into a reliable component in an automated system. It provides the necessary guardrails that make a self-correcting feedback loop not just possible, but robust.

Implementation Deep Dive: The Self-Correction Mechanism

With the conceptual framework in place, let’s transition from theory to execution. This deep dive will walk you through the five critical steps for building a robust self-correction mechanism using Vertex AI, with practical code examples implemented in Google Apps Script—a perfect environment for automating tasks within the AC2F Streamline Your Google Drive Workflow ecosystem.

Step 1: Defining Your Strict JSON Schema in the Initial Prompt

The entire self-correction loop hinges on a clear, unambiguous “contract” with the language model. This contract is the JSON schema you define in your initial prompt. By instructing the model to adhere to a specific structure, you create a verifiable output that your application can programmatically validate.

A well-defined schema prompt should be explicit, providing not just the keys and data types, but also clear instructions on how to handle missing information.

Here is an example of a robust initial prompt designed to extract contact information from a block of text:


**Instruction:**

Analyze the following email body and extract the contact information for the primary sender.

**Rules:**

1.  You MUST respond with ONLY a single, valid JSON object. Do not include any explanatory text, markdown formatting, or any characters before or after the JSON object.

2.  The JSON object must strictly adhere to the schema defined below.

3.  If a piece of information (e.g., 'company') is not found in the text, the corresponding JSON key should be set to `null`.

4.  The 'email' field is mandatory. If an email cannot be found, return a JSON object with an 'error' key describing the issue.

**JSON Schema:**

{

"type": "object",

"properties": {

"name": {

"type": "string",

"description": "The full name of the contact."

},

"email": {

"type": "string",

"description": "The contact's email address."

},

"company": {

"type": "string",

"description": "The company the contact works for."

}

},

"required": ["name", "email"]

}

**Email Body to Analyze:**

"Hi team,

Just following up on our discussion. Please feel free to reach out if you have questions.

Best,

Jane Doe

Senior Innovator

[email protected]"

This prompt leaves no room for ambiguity. It tells the model what to do, how to format the output, and how to handle exceptions, setting a perfect foundation for validation.

Step 2: Executing the API Call from Google Apps Script

Google Apps Script (GAS) is a serverless JavaScript platform that makes it easy to call external APIs like Vertex AI. We use the built-in UrlFetchApp service to make the authenticated request.

First, ensure your Apps Script project is linked to a Google Cloud Platform (GCP) project with the Vertex AI API enabled.

Here’s a function to call the Gemini model endpoint:


/**

* Calls the Vertex AI Gemini API with a given prompt.

*

* @param {string} promptText The full prompt to send to the model.

* @return {string} The raw text response from the model.

*/

function callVertexAI(promptText) {

const GCP_PROJECT_ID = 'your-gcp-project-id';

const MODEL_ID = 'gemini-1.0-pro'; // Or your preferred model

const API_ENDPOINT = `https://us-central1-aiplatform.googleapis.com/v1/projects/${GCP_PROJECT_ID}/locations/us-central1/publishers/google/models/${MODEL_ID}:generateContent`;

const payload = {

"contents": [{

"parts": [{

"text": promptText

}]

}],

"generation_config": {

"temperature": 0.2,

"topP": 0.8,

"topK": 40,

"maxOutputTokens": 512,

}

};

const options = {

'method': 'post',

'contentType': 'application/json',

'headers': {

'Authorization': 'Bearer ' + ScriptApp.getOAuthToken()

},

'payload': JSON.stringify(payload),

'muteHttpExceptions': true // Important for capturing error responses

};

const response = UrlFetchApp.fetch(API_ENDPOINT, options);

const responseCode = response.getResponseCode();

const responseBody = response.getContentText();

if (responseCode === 200) {

const jsonResponse = JSON.parse(responseBody);

// Navigate the Gemini response structure to get the text content

return jsonResponse.candidates[0].content.parts[0].text;

} else {

throw new Error(`API call failed with status ${responseCode}: ${responseBody}`);

}

}

This function encapsulates the API call, including authentication via ScriptApp.getOAuthToken(), and returns the model’s raw text output, which we expect to be a JSON string.

Step 3: Implementing a try-catch Block for Schema Validation

This is where the “correction” process is triggered. We attempt to parse and validate the model’s response. If at any point the output fails our checks, we catch the error and gather context for the correction prompt.

The first line of defense is JSON.parse(). If the model returns malformed JSON (e.g., with extra text or a trailing comma), this will immediately throw an error. After parsing, we perform a secondary check to ensure the object contains the required keys and correct data types.


/**

* Validates the parsed JSON object against our required schema.

* Throws an error if validation fails.

*

* @param {Object} data The parsed JSON object from the LLM.

*/

function validateContactSchema(data) {

if (typeof data !== 'object' || data === null) {

throw new Error("Validation Error: Response is not a valid object.");

}

if (!data.hasOwnProperty('name') || typeof data.name !== 'string') {

throw new Error("Validation Error: Missing or invalid type for required key 'name'.");

}

if (!data.hasOwnProperty('email') || typeof data.email !== 'string') {

throw new Error("Validation Error: Missing or invalid type for required key 'email'.");

}

// All checks passed

}

// --- Main execution logic ---

try {

const initialPrompt = "..." // The full prompt from Step 1

const llmResponse = callVertexAI(initialPrompt);

// 1. First validation: Can it be parsed as JSON?

const parsedJson = JSON.parse(llmResponse);

// 2. Second validation: Does it match our schema rules?

validateContactSchema(parsedJson);

Logger.log("Success! Valid JSON received:");

Logger.log(parsedJson);

} catch (error) {

Logger.log("Validation failed. Initiating correction process.");

Logger.log("Error: " + error.message);

// In the next step, we'll use this error to build a correction prompt.

}

The catch block is our entry point to the self-correction loop. It now holds a specific error message explaining why the validation failed.

Step 4: Crafting the Dynamic ‘Correction Prompt’ with Error Context

A generic “please try again” is ineffective. For true self-correction, the model needs context. The correction prompt must be dynamically generated to include the original request, the model’s flawed output, and the specific error it caused.

This feedback loop teaches the model its mistake in the context of the immediate task.


/**

* Creates a dynamic correction prompt based on the error.

*

* @param {string} originalPrompt The initial prompt sent to the model.

* @param {string} invalidResponse The flawed raw response from the model.

* @param {string} errorMessage The specific error message from the catch block.

* @return {string} A new, detailed prompt for the model to correct its mistake.

*/

function createCorrectionPrompt(originalPrompt, invalidResponse, errorMessage) {

return `You are a self-correction AI assistant. Your previous attempt to respond to a request resulted in an error.

Your task is to analyze your mistake and provide a new, corrected response that strictly follows all original rules.

**Original Request:**

${originalPrompt}

**Your Previous Invalid Response:**

${invalidResponse}

**Error Caused by Your Response:**

${errorMessage}

**Correction Instruction:**

Please re-evaluate the original request and provide a new response that fixes the specified error. Ensure your new output is ONLY a single, valid JSON object that strictly adheres to the schema and all rules defined in the original request.

`;

}

This function creates a highly contextual prompt that gives the model everything it needs to understand its failure and attempt a successful correction.

Step 5: Managing Retry Logic and Circuit Breakers to Prevent Infinite Loops

Finally, we must prevent a scenario where the model repeatedly fails, leading to an infinite loop that exhausts API quotas and execution time. We achieve this by wrapping our logic in a loop with a fixed number of retries—a “circuit breaker.”

If the model fails to correct itself within, for example, three attempts, the process terminates and logs the failure for manual inspection.

Here is the complete, integrated workflow:


function processTextWithSelfCorrection(initialPrompt) {

const MAX_RETRIES = 3;

let lastError = null;

let currentPrompt = initialPrompt;

for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {

Logger.log(`--- Attempt ${attempt} of ${MAX_RETRIES} ---`);

try {

// Step 2: Execute the API call

const llmResponse = callVertexAI(currentPrompt);

Logger.log("Received response: " + llmResponse);

// Step 3: Attempt to parse and validate

const parsedJson = JSON.parse(llmResponse);

validateContactSchema(parsedJson); // Using the validator from Step 3

// If both steps succeed, we have our valid data.

Logger.log("Success! Schema validation passed.");

return { success: true, data: parsedJson };

} catch (error) {

lastError = error;

Logger.log(`Attempt ${attempt} failed: ${error.message}`);

if (attempt < MAX_RETRIES) {

// Step 4: Craft the correction prompt for the next iteration

const invalidResponse = error.llmRawResponse || "Response could not be retrieved.";

currentPrompt = createCorrectionPrompt(initialPrompt, invalidResponse, error.message);

Logger.log("Generated new correction prompt for next attempt.");

}

}

}

// If the loop completes without a successful return, it has failed.

Logger.log(`Failed to get a valid response after ${MAX_RETRIES} attempts.`);

return { success: false, error: `Final error: ${lastError.message}` };

}

// Example Usage:

// const myInitialPrompt = "..." // Your prompt from Step 1

// const result = processTextWithSelfCorrection(myInitialPrompt);

// if (result.success) {

//   // Do something with result.data

// } else {

//   // Handle the final failure

// }

This final structure elegantly combines all five steps into a resilient, self-correcting workflow. It attempts a task, validates the outcome, provides targeted feedback upon failure, and includes a safety mechanism to prevent runaway execution.

Practical Example Code and Walkthrough

Theory is great, but seeing a self-correcting agent in action is where the real understanding clicks. We’ll build a practical, end-to-end workflow that you can adapt for your own use cases. We’ll use Google Apps Script to orchestrate the process, as it provides a fantastic, serverless environment that integrates natively with Automated Client Onboarding with Google Forms and Google Drive. tools like Gmail and Sheets.

Use Case: Automatically Categorizing Support Tickets into a Google Sheet

Imagine a support inbox flooded with customer emails. Manually reading, categorizing, and logging each one is a time-consuming, soul-crushing task. Our agentic workflow will automate this process entirely.

The Goal:

Monitor a Gmail inbox for new emails with the label “Support-Ticket”.
For each new email, use the Vertex AI Gemini API to extract key information:

A concise* summary** of the issue.

A* category** from a predefined list (Billing, Technical Issue, Feature Request, General Inquiry).

A* priority** level (Low, Medium, High).

Log this structured data into a designated Google Sheet.

The Self-Correction Challenge:

What happens if the AI model returns a response that doesn’t fit our rigid structure?

It might hallucinate a new category like “Account Question” instead of using our predefined list.
It might return a poorly formatted JSON string, causing our parsing script to fail.
It might fail to extract a priority level because the user’s email was too vague.

Instead of just failing and moving on, our workflow will catch this error, inform the model of its mistake, and ask it to try again with the new context. This is the self-correction loop.

Annotated Apps Script Code for the Full Workflow

This entire workflow can be contained within a single Google Apps Script file, connected to a Google Sheet.

Setup:

Create a new Google Sheet. Note its ID from the URL.
Go to Extensions > Apps Script.
Paste the code below into the Code.gs file.
Update the placeholder constants (GCP_PROJECT_ID, SHEET_ID, SHEET_NAME).
In the Apps Script editor, go to Project Settings and enable the “Show ‘appsscript.json’ manifest file in editor” option. Add the following to your appsscript.json to enable the necessary OAuth scopes:


{

"timeZone": "America/New_York",

"dependencies": {},

"exceptionLogging": "STACKDRIVER",

"oauthScopes": [

"https://www.googleapis.com/auth/script.external_request",

"https://www.googleapis.com/auth/gmail.readonly",

"https://www.googleapis.com/auth/spreadsheets"

],

"runtimeVersion": "V8"

}

Set up a trigger to run the processSupportTickets function on a schedule (e.g., every 5 minutes).


// --- CONFIGURATION CONSTANTS ---

const GCP_PROJECT_ID = 'your-gcp-project-id'; // <-- Replace with your GCP Project ID

const MODEL_ID = 'gemini-1.0-pro';

const LOCATION = 'us-central1'; // Or your preferred GCP region

const SHEET_ID = 'your-google-sheet-id'; // <-- Replace with your Sheet ID

const SHEET_NAME = 'Tickets'; // <-- Replace with your target sheet name

const GMAIL_LABEL = 'Support-Ticket';

const ALLOWED_CATEGORIES = ['Billing', 'Technical Issue', 'Feature Request', 'General Inquiry'];

const ALLOWED_PRIORITIES = ['Low', 'Medium', 'High'];

/**

* Main function to be triggered. Fetches threads with the specified label,

* processes them, and marks them as read.

*/

function processSupportTickets() {

const threads = GmailApp.search(`label:${GMAIL_LABEL} is:unread`);

if (threads.length === 0) {

Logger.log('No new support tickets found.');

return;

}

const sheet = SpreadsheetApp.openById(SHEET_ID).getSheetByName(SHEET_NAME);

// Add headers if the sheet is empty

if (sheet.getLastRow() === 0) {

sheet.appendRow(['Timestamp', 'From', 'Subject', 'Category', 'Priority', 'Summary', 'Status']);

}

for (const thread of threads) {

const message = thread.getMessages()[0]; // Process the first message in the thread

const emailBody = message.getPlainBody();

const emailSubject = message.getSubject();

const emailFrom = message.getFrom();

try {

Logger.log(`Processing ticket: "${emailSubject}"`);

let structuredData = callVertexAI(emailBody, emailSubject);

// --- SELF-CORRECTION LOOP ---

// If the first attempt gives an invalid response, we try to correct it.

let attempts = 0;

const maxAttempts = 2; // Initial attempt + 1 correction

while (attempts < maxAttempts) {

const validationError = validateResponse(structuredData);

if (!validationError) {

Logger.log('Validation successful.');

break; // Exit loop if data is valid

}

attempts++;

Logger.log(`Attempt ${attempts} failed. Reason: ${validationError}. Retrying...`);

if (attempts >= maxAttempts) {

throw new Error(`Failed to get valid data after ${maxAttempts} attempts. Last error: ${validationError}`);

}

// This is the core of self-correction: we pass the error back to the model.

structuredData = callVertexAI(emailBody, emailSubject, validationError);

}

// Append the validated data to the Google Sheet

sheet.appendRow([

new Date(),

emailFrom,

emailSubject,

structuredData.category,

structuredData.priority,

structuredData.summary,

'Processed'

]);

// Mark the thread as read and remove the label to prevent reprocessing

thread.markRead();

thread.removeLabel(GmailApp.getUserLabelByName(GMAIL_LABEL));

} catch (e) {

Logger.log(`CRITICAL ERROR processing ticket "${emailSubject}": ${e.message}`);

// Optionally, add a row to the sheet indicating failure

sheet.appendRow([new Date(), emailFrom, emailSubject, '', '', e.message, 'Failed']);

thread.markRead(); // Mark as read to avoid getting stuck in a failure loop

}

}

}

/**

* Calls the Vertex AI Gemini API to analyze email content.

* @param {string} emailBody - The plain text body of the email.

* @param {string} emailSubject - The subject of the email.

* @param {string|null} feedback - Feedback from a previous failed attempt.

* @return {Object} The parsed JSON object from the model.

*/

function callVertexAI(emailBody, emailSubject, feedback = null) {

const accessToken = ScriptApp.getOAuthToken();

const url = `https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${GCP_PROJECT_ID}/locations/${LOCATION}/publishers/google/models/${MODEL_ID}:generateContent`;

// The system prompt is crucial. It sets the rules for the AI.

let system_prompt = `You are an expert support ticket categorization agent.

Your task is to analyze an email and return a JSON object with three keys: "summary", "category", and "priority".

- "summary": A concise, one-sentence summary of the user's issue.

- "category": Must be one of the following exact values: ${ALLOWED_CATEGORIES.join(', ')}.

- "priority": Must be one of the following exact values: ${ALLOWED_PRIORITIES.join(', ')}.

Do not include any text or markdown formatting before or after the JSON object.`;

// If there's feedback, we add it to the prompt to guide the correction.

if (feedback) {

system_prompt += `\n\nIMPORTANT: Your previous attempt failed with the following error: "${feedback}".

Please correct your mistake and provide a valid JSON response based on this feedback. Re-analyze the original request carefully.`;

}

const requestBody = {

"contents": [{

"role": "user",

"parts": [{

"text": `Subject: ${emailSubject}\n\nBody:\n${emailBody}`

}]

}],

"systemInstruction": {

"parts": [{

"text": system_prompt

}]

},

"generationConfig": {

"responseMimeType": "application/json", // Requesting JSON output directly

"temperature": 0.2,

"maxOutputTokens": 256

}

};

const options = {

'method': 'post',

'contentType': 'application/json',

'headers': {

'Authorization': 'Bearer ' + accessToken

},

'payload': JSON.stringify(requestBody),

'muteHttpExceptions': true // Important to catch HTTP errors manually

};

const response = UrlFetchApp.fetch(url, options);

const responseCode = response.getResponseCode();

const responseBody = response.getContentText();

if (responseCode !== 200) {

throw new Error(`Vertex AI API Error: ${responseCode} - ${responseBody}`);

}

// The API should return clean JSON, but we parse it defensively.

try {

const jsonText = responseBody.match(/```json\n([\s\S]*?)\n```/)?.[1] || responseBody;

const candidates = JSON.parse(jsonText).candidates;

if (!candidates || candidates.length === 0) {

throw new Error("No content candidates returned from API.");

}

return JSON.parse(candidates[0].content.parts[0].text);

} catch (e) {

throw new Error(`Failed to parse JSON from AI response: ${e.message}. Raw response: ${responseBody}`);

}

}

/**

* Validates the structured data from the AI against our rules.

* @param {Object} data - The parsed JSON object from the AI.

* @return {string|null} An error message if validation fails, otherwise null.

*/

function validateResponse(data) {

if (!data) return "AI response was null or undefined.";

if (!data.category || !ALLOWED_CATEGORIES.includes(data.category)) {

return `Invalid category "${data.category}". Must be one of: ${ALLOWED_CATEGORIES.join(', ')}.`;

}

if (!data.priority || !ALLOWED_PRIORITIES.includes(data.priority)) {

return `Invalid priority "${data.priority}". Must be one of: ${ALLOWED_PRIORITIES.join(', ')}.`;

}

if (!data.summary || typeof data.summary !== 'string' || data.summary.length < 10) {

return "Summary is missing or too short.";

}

return null; // All checks passed

}

Analyzing a Failed Attempt and the Subsequent Successful Correction

Let’s trace a real-world scenario where the self-correction loop is essential.

The Incoming Email:

Subject: Can’t log in
From: [email protected]
Body: Hey, your app is broken. I keep trying to reset my password but the link you send me doesn’t work. I need to get into my account to pay my bill. This is urgent.

Attempt 1: The Failure

The processSupportTickets function triggers and sends the email content to callVertexAI. The model, trying to be helpful but not strictly following the rules, returns the following JSON:


{

"summary": "User is unable to log in or reset their password and needs to pay a bill.",

"category": "Account Access",

"priority": "Urgent"

}

The code receives this response. The validateResponse function is called, and it immediately flags two problems:

The category “Account Access” is not in our ALLOWED_CATEGORIES list.
The priority “Urgent” is not in our ALLOWED_PRIORITIES list.

The validateResponse function returns the error string: Invalid category "Account Access". Must be one of: Billing, Technical Issue, Feature Request, General Inquiry.

Attempt 2: The Correction

The while loop in processSupportTickets catches this error. It doesn’t give up. Instead, it calls callVertexAI a second time, but now it includes the error message as feedback.

The new system prompt sent to Vertex AI now looks like this:

You are an expert support ticket categorization agent.

Your task is to analyze an email and return a JSON object with three keys: “summary”, “category”, and “priority”.

“summary”: A concise, one-sentence summary of the user’s issue.

“category”: Must be one of the following exact values: Billing, Technical Issue, Feature Request, General Inquiry.

“priority”: Must be one of the following exact values: Low, Medium, High.

Do not include any text or markdown formatting before or after the JSON object.

**IMPORTANT: Your previous attempt failed with the following error: “Invalid category “Account Access”. Must be one of: Billing, Technical Issue, Feature Request, General Inquiry.”.

Please correct your mistake and provide a valid JSON response based on this feedback. Re-analyze the original request carefully.**

Armed with this explicit correction, the model understands its mistake. It re-evaluates the original email with the new constraints in mind. It recognizes that the password reset is a technical problem and the mention of a bill points towards a “Billing” context. It also maps “urgent” to the closest valid priority.

The model now returns a valid response:


{

"summary": "User cannot reset their password to access their account to pay a bill.",

"category": "Technical Issue",

"priority": "High"

}

This time, when validateResponse is called, all checks pass. The function returns null. The loop breaks, and the corrected, structured data is successfully appended to our Google Sheet.

Final Result in Google Sheet:

| :--- | :--- | :--- | :--- | :--- | :--- | :--- |

Without the self-correction loop, this ticket would have been logged as an error or required manual intervention. With it, the workflow autonomously recovered from its own failure, demonstrating a powerful and resilient form of automation.

Advanced Considerations for Workspace Architects

Building a self-correcting loop is a powerful step towards agentic autonomy, but moving from a prototype to a production-grade system requires a deeper architectural perspective. As an architect, your focus shifts from “does it work?” to “is it observable, cost-effective, and extensible?” Let’s explore the critical considerations for building robust, enterprise-ready self-correcting workflows.

Monitoring and Logging for Loop Performance

An unmonitored corrective loop is a black box. It could be silently failing, caught in an expensive cycle, or introducing significant latency. Without proper instrumentation, you cannot diagnose problems or measure the efficacy of your prompts and tools. Effective monitoring is non-negotiable.

Key Metrics to Track:

Loop Trigger Rate: How often is the correction mechanism invoked? A sudden spike can indicate a systemic issue, such as a change in an external API, a poorly performing model update, or a new class of user queries that your prompts don’t handle well.
Correction Latency: Measure the time spent within each correction cycle and the total time added to a task by retries. This helps you understand the performance impact on the user experience.
Iteration Count per Task: Log the number of retries for each task. A high average number of iterations suggests that your initial prompts or tool definitions are not effective enough and need refinement.
Failure Categories: Don’t just log that an error occurred. Categorize it. Was it a ValidationError, an APITimeoutError, a ContentSafetyViolation, or a custom ToolExecutionError? This data is invaluable for prioritizing improvements.
Terminal Failure Rate: After the maximum number of retries, how often does the workflow still fail? This is your ultimate measure of the system’s brittleness.

Implementation with Google Cloud’s Operations Suite:

Structured Logging: Instead of printing plain text, emit JSON-formatted logs from your agent’s execution environment (e.g., Cloud Functions, Cloud Run). This allows for powerful, field-based querying in Cloud Logging. Include a unique trace ID to correlate all events for a single agentic task.


{

"severity": "WARNING",

"message": "Self-correction loop triggered.",

"traceId": "a1b2c3d4-e5f6-7890-g1h2-i3j4k5l6m7n8",

"loopIteration": 1,

"triggerError": "ValidationError",

"triggerDetails": "Invalid JSON format in tool call.",

"correctionStrategy": "Re-prompting with Pydantic schema."

}

Log-Based Metrics: In Cloud Monitoring, create metrics from your structured logs. For example, you can create a counter metric that increments every time a log with message: "Self-correction loop triggered." is ingested.
Dashboards and Alerting: Build a dedicated dashboard in Cloud Monitoring to visualize these key metrics over time. Set up alerting policies to notify your team of anomalies, such as “Loop Trigger Rate exceeds 50/minute” or “Terminal Failure Rate is greater than 5% over the last hour.”

Cost Implications of Automated Retries

Autonomy without guardrails is a recipe for budget overruns. Each iteration in a corrective loop incurs costs from multiple sources, and these can accumulate rapidly if not managed.

Primary Cost Drivers:

LLM API Calls: This is often the most significant cost. Every retry involves another call to the Vertex AI API, consuming input and output tokens. The context for a correction prompt is often larger than the initial prompt, as it includes the previous failed attempt, the error message, and clarifying instructions.
Tool Execution: If the agent’s action involves calling other services—a Cloud Function, a BigQuery job, or a third-party API—you pay for that execution on every attempt.
Compute Resources: The environment hosting your agent logic has its own compute costs, which are directly proportional to the time spent processing and retrying tasks.

Cost Control Strategies:

Implement a Circuit Breaker: This is the most critical control. Set a hard cap on the number of retries for any single task (e.g., a maximum of 3 attempts). If the task still fails, the loop should terminate and escalate the issue, either by returning a failure to the user or flagging it for manual review.
Use Exponential Backoff: For transient errors like API rate limits (429 Too Many Requests) or temporary network issues, retrying immediately is counterproductive. Implement an exponential backoff strategy, where the delay between retries increases with each failure (e.g., 1s, 2s, 4s). This reduces pressure on downstream systems and avoids wasteful, rapid-fire API calls.
Tiered Model Usage: Not every correction requires your most powerful (and expensive) model. Consider a tiered approach. For simple syntax corrections, you might use a faster, cheaper model like Gemini 1.5 Flash. If that fails, you can escalate the next retry to a more capable model like Gemini 1.5 Pro.
Set Budgets and Alerts: Use Google Cloud Billing to set programmatic budget alerts for your project. This acts as a crucial safety net to catch any runaway processes that your other controls might miss, preventing catastrophic budget surprises.

Expanding the Pattern Beyond Schema Failures

JSON schema validation is just the beginning. The true power of the self-correction pattern is its applicability to a wide range of failure modes. By architecting your tools and agent logic correctly, you can teach the agent to recover from much more complex situations.

Handling Tool Execution Errors:

Your tools should not be black boxes that simply raise Exception(). They should return rich, descriptive error messages that the LLM can understand and act upon.

Example 1: Invalid Input: A get_user_profile tool is called with a non-existent user_id.
Bad Error: raise Exception("User not found")
Good Error: Return a structured error message: {"error": "ToolExecutionError", "message": "User with ID 'u-12345' does not exist. Suggest checking the ID or searching for the user by name."}.
Agent’s Action: The agent receives this feedback, understands the problem, and can then use a different tool, like search_user_by_name, to find the correct ID.
Example 2: API Failures: A tool that calls an external weather API receives a 503 Service Unavailable error.
Tool’s Response: Return {"error": "APIFailureError", "message": "The external weather service is temporarily unavailable. Please try again later or try a different location."}.
Agent’s Action: The agent can inform the user of the outage and, depending on its instructions, either wait and retry or suggest proceeding without the weather data.

Handling Content and Safety Violations:

When a model’s response is blocked by Vertex AI’s safety filters, you can catch this specific exception. Instead of terminating, you can feed this back into the loop.

Correction Prompt: “Your previous response was blocked by a safety filter. The query was about [original query]. Please generate a new, helpful, and safe response that adheres to the safety policy without referencing the blocked content.”

Creating a “Critique-and-Refine” Loop:

This is a more advanced application where you introduce a second agent or tool that acts as a “critic.”

Generate: The primary agent generates a response.
Critique: A “Validator Agent” or a specialized tool is invoked to check the response against a set of criteria (e.g., fact-checking against a knowledge base, checking for tone consistency, ensuring all parts of the user’s query were addressed).
Refine: The critique is fed back to the primary agent as a new prompt. “Your previous response was good, but it failed a fact-check on the founding date of the company. The correct date is YYYY-MM-DD. Please correct your response.”

By thinking of self-correction as a general-purpose framework for handling exceptions—not just schema errors—you can build dramatically more resilient, reliable, and intelligent agentic systems.

Conclusion: From Fragile Scripts to Autonomous Agents

We’ve journeyed far beyond the realm of simple, brittle automation. The path we’ve explored in this article marks a fundamental paradigm shift—a move away from hand-coded, deterministic scripts that shatter at the first sign of an unexpected input, toward intelligent, autonomous agents that can reason, adapt, and self-correct. The techniques we’ve covered, from robust tool design and function calling to implementing cyclical reasoning patterns with frameworks like ReAct on Vertex AI, are not just incremental improvements. They are the foundational building blocks for a new class of enterprise-grade AI systems that are resilient by design.

The distinction is critical. A fragile script executes a predefined sequence of commands. An autonomous agent, powered by the Vertex AI ecosystem, pursues a goal. When it encounters an error, it doesn’t just fail; it analyzes the feedback, re-evaluates its strategy, and attempts a different approach. This is the difference between a simple tool and a true digital colleague—one that you can trust to handle complex, dynamic workflows with a degree of autonomy that was previously the stuff of science fiction.

The Business Impact of Building Resilient AI Systems

Adopting this agentic model isn’t merely a technical exercise; it’s a strategic business decision with profound, compounding benefits. When you build for resilience, you unlock value across the entire organization.

Drastically Reduced Operational Overhead: Self-correcting systems translate directly to fewer support tickets, fewer late-night pages for on-call engineers, and a lower total cost of ownership. Instead of constantly patching brittle pipelines, your technical teams can focus their expertise on innovation and building new capabilities. The system, in essence, becomes a part of the maintenance team.
Unprecedented Reliability and Trust: For AI to be mission-critical, it must be dependable. Agentic workflows that can gracefully handle API changes, transient network errors, or malformed data ensure that your core business processes continue to run smoothly. This builds critical trust with both internal stakeholders and external customers who rely on your AI-powered services.
True Scalability and Adaptability: Brittle systems require engineering intervention for every new edge case. Resilient agents, however, are built to handle ambiguity. They can often navigate unforeseen scenarios without requiring a single line of new code, allowing you to scale your AI initiatives and adapt to changing business environments at a velocity that is simply unattainable with traditional automation.
An Engine for Innovation: By abstracting away the low-level, error-prone tasks, you empower your organization to think bigger. The conversation shifts from “How do we prevent this from breaking?” to “What new, complex problem can we solve now that we have a reliable agent to execute the workflow?” This frees up your most valuable resource—human ingenuity—to be applied to strategic, high-impact challenges.

Your Next Steps in Scaling Intelligent Automation

The journey from concept to a production-grade autonomous agent is an iterative one. The power of Vertex AI is that it provides a scalable, secure, and integrated platform to support you at every stage. Here’s how you can begin applying these principles today.

Identify the Brittleness: Start by auditing your existing automations. Where do your scripts most often fail? Is it a flaky API, inconsistent data formats, or a complex multi-step process? Pinpoint a workflow that is high-value but currently requires significant manual oversight. This is your ideal first candidate for an agentic transformation.
Master the Tools: Dive deeper into the Vertex AI toolkit. Revisit the concepts of function calling with Gemini and explore the LangChain on Vertex AI integrations we discussed. Experiment in a controlled environment. Build a simple agent that uses one or two tools and has a clear self-correction loop. The goal is not to boil the ocean, but to build hands-on familiarity and confidence with the core components.
Instrument, Observe, and Iterate: Treat your agent’s deployment as the beginning, not the end. Implement comprehensive logging and monitoring from day one. Track its decisions, the tools it uses, the errors it encounters, and how it recovers. This observational data is the lifeblood of improvement. Use these insights to refine its prompts, improve its tools, and expand its capabilities over time.
Champion the Mindset Shift: Building autonomous systems is as much a cultural shift as it is a technological one. Share your successes and learnings with your team and the wider organization. Demonstrate the power of building systems that are designed to handle failure, not just avoid it. As you prove the value of this approach, you will build the momentum needed to tackle increasingly complex and ambitious automation challenges.

The future of intelligent automation is not about creating perfect, unbreakable code. It’s about creating intelligent, resilient systems that understand their goals and are empowered to achieve them, even when the path forward is anything but perfect. With Vertex AI, you have the platform to start building that future now.

Vo Tu Duc

A Google Developer Expert, Google Cloud Innovator

Stop Doing Manual Work. Scale with AI.