Leveraging LLMs for Smarter Automation: How AI Agents Handle Unstructured Data

Traditional Robotic Process Automation (RPA) has a well-known secret: it’s fragile. For years, businesses have built automation bots that rely on screen scraping and rigid, rules-based logic. These bots work perfectly—until a button on a website moves, a form field changes, or an invoice arrives in a slightly different format. The result? Broken workflows, manual interventions, and a high-maintenance process that often negates the promise of automation.

The core of this fragility lies in RPA's historical inability to handle unstructured data. Invoices, emails, contracts, and customer support tickets don't follow a neat, predictable structure. This is where modern AI, specifically Large Language Models (LLMs), changes everything.

At rpa.do, we believe the future of automation isn't just about mimicry; it's about comprehension. By integrating the power of LLMs directly into our developer-first, API-driven platform, we empower businesses to build intelligent AI agents that don't just see data—they understand it.

The Unstructured Data Wall

Why do traditional bots crumble when faced with slight variations? Because they are programmed to look for data in specific places.

• Traditional Bot Logic: "Find the box at pixel coordinates (450, 300) and extract the number inside."
• The Reality: The next PDF invoice has a different layout, and the "total amount" is now at (500, 320). The bot fails.

This is the "unstructured data wall." It represents the massive portion of business information that has, until now, remained stubbornly resistant to automation. Processes like invoice processing, sales order entry from emails, and customer ticket routing have required human cognition to interpret context and variation. Attempting to automate them with old-school RPA led to a web of complex rules and constant break-fixes.

From Brittle Bots to Intelligent Agents: The LLM Revolution

Large Language Models (like the technology behind ChatGPT) are designed to understand context, semantics, and intent within human language and documents. They don't need fixed templates. You can provide an LLM with a document and ask a question in plain English.

• Intelligent Agent Logic: "Read this document and find the total invoice amount."

The LLM will parse the entire document, identify phrases like "Total Due," "Amount Payable," or "Balance," and intelligently extract the correct figure, regardless of its position.

This is the fundamental shift that rpa.do brings to life. Our agents are AI-native. Instead of relying on brittle UI interactions, you define robust workflows as code that leverage LLMs to handle the messy, unstructured parts of a process. This 'Business-as-Code' approach makes your automations more reliable, scalable, and easy to maintain.

RPA as Code: Processing an Invoice with an AI Agent

Let's see what this looks like in practice. Traditional RPA would require a clunky visual designer and dozens of steps to record clicks and screen scrapes. With rpa.do, you define the entire intelligent workflow with a simple, clean API call.

Imagine you want to automate processing invoices that arrive as PDF attachments in an email inbox.

import { Agent } from '@do/rpa';

// Create an agent to handle accounts payable tasks
const accountsPayableAgent = new Agent('ap-processor-agent');

// Define and run the intelligent workflow
async function processNewInvoices() {
  const result = await accountsPayableAgent.run({
    workflow: 'extract_invoice_data_and_create_bill',

    // 1. Source: Watch an email inbox for new invoices
    source: {
      type: 'email_inbox',
      id: 'invoices@company.com',
      filter: { has_attachment: '.pdf' }
    },
    
    // 2. Transform: Use an AI-powered step to understand the PDF
    transform: {
      type: 'llm_extract',
      prompt: `From the attached document, extract the following as a JSON object: 
               invoiceNumber, vendorName, dueDate, and totalAmount.`
    },

    // 3. Destination: Use the structured data to create a bill in QuickBooks
    destination: {
      type: 'quickbooks_api',
      action: 'create_bill',
      // Map the clean data extracted by the LLM
      map_fields: {
         vendor: '{{transform.vendorName}}',
         dueDate: '{{transform.dueDate}}',
         amount: '{{transform.totalAmount}}'
      }
    }
  });

  console.log(`Automation run complete. ${result.processed} invoices processed.`);
}

runNewInvoices();

In this example, the transform step is where the magic happens. The rpa.do agent securely passes the PDF to an LLM, which "reads" the document and returns clean, structured JSON. This predictable output can then be reliably used in the next step of the automation—in this case, creating a bill via the QuickBooks API.

The automation is no longer dependent on the invoice's layout. It’s dependent on the LLM's ability to understand the document's content, making it vastly more resilient.

The Benefits of Code-Driven, Intelligent Automation

Adopting an AI-native, 'Business-as-Code' approach with rpa.do delivers transformative benefits:

• Radical Resilience: Automations no longer break due to minor UI or document layout changes. The AI adapts to variations, dramatically reducing maintenance overhead.
• Expanded Automation Scope: Processes once deemed "too complex" or "too variable" for automation are now prime candidates. From parsing legal contracts to triaging support tickets based on sentiment, the possibilities are immense.
• True Scalability: Confidently process thousands of documents, emails, or records. Since the logic is robust and API-driven, it scales flawlessly without the bottlenecks of UI-based bots.
• Developer-First Experience: Manage your automations like modern software. Use version control (Git), integrate with CI/CD pipelines, and collaborate with your team using familiar coding practices.

Stop Building Brittle Bots. Start Deploying Intelligent Agents.

The era of fragile, screen-scraping RPA is over. The future of workflow automation is intelligent, resilient, and defined as code. By embedding the comprehension power of LLMs into a seamless, API-driven framework, rpa.do provides the tools for developers and enterprises to build the next generation of software robots.

Ready to automate anything? Explore the rpa.do platform and start deploying intelligent agents today.