Built In Austin Texas
Powered by Redbull
Powered by Redbull
Everyone talks about AI replacing humans at scale. We actually did it. Here's what that looks like in production.
When a customer emails asking about their order status at 2 AM, our AI employee doesn't just send a canned response. It executes a multi-step investigation that would take a human agent 3-4 minutes, completing it in under 10 seconds.
The workflow looks like this: First, it searches Shopify's customer database by email to locate all associated orders. Then it retrieves the complete order record—line items, fulfillment status, payment details, shipping address, and crucially, the fulfillment tracking data. Here's where it gets interesting: if the order shows "fulfilled" in Shopify but has multiple fulfillments (one for shipping insurance, one for actual products), the system parses each fulfillment individually to find the tracking number. It then evaluates the shipment status—not just whether something shipped, but whether it's in transit, out for delivery, or actually confirmed delivered by the carrier.
Only after this complete investigation does it respond to the customer with accurate, specific information: "Your order 1234567 is currently in transit in Calgary, AB as of October 13th. Expected delivery is 3-5 business days from that date."
Processing refunds is where most automation systems fail catastrophically. You can't just click "refund" and hope for the best—there are payment disputes to check, fraud patterns to detect, return policies to enforce, and multiple payment processors to navigate.
Our refund workflow starts with order validation: Is this order real? Is it eligible for refund under the 30-day policy? Are there any pending payment disputes flagged in Stripe or PayPal? The system checks both payment processors because customers use different methods, and a dispute in one system isn't visible in the other.
If the order is over 30 days old, the system doesn't just reject it—it generates a unique store credit code using the pattern CUST-[CustomerFirstName]-[OrderNumber], creates a discount in Shopify with precise constraints (minimum purchase equals discount amount, one use per customer, expires in two years), and sends a personalized message explaining the alternative.
For approved refunds, it determines the payment processor, executes the refund through the appropriate API (Stripe or PayPal), documents the transaction in Shopify's order timeline, updates the support ticket status, and sends a confirmation email—all without human intervention except for final approval in dry-run mode.
"Cancel my order" seems straightforward. It's not. The complexity depends entirely on fulfillment status and which warehouse system has the order.
For unfulfilled orders in Shopify's direct system, it's clean: cancel in Shopify, process the refund through the original payment method, update the ticket, notify the customer. Done.
But when orders have already moved to third-party fulfillment partners like SCS (warehouse management system), the workflow becomes surgical. The system must verify the order hasn't entered the picking stage by checking for specific Shopify tags (SCS_Picking, SCSCA). If those tags exist, it queries the SCS portal to confirm fulfillment status. Only if the order is still cancellable does it proceed—executing the cancellation in SCS, removing the fulfillment tags in Shopify, processing the refund, and documenting every step.
Customers ask surprisingly nuanced questions: "What size are your widgets?" "Do they come in different sizes?" "How do I activate the privacy pen?"
The challenge isn't answering these questions—it's detecting when customers are actually asking them. People don't say "widget 1"—they say "blanket," or "your product," or "it." Our intent detection system had to learn that "charging issues" definitively means the widget 4 (it's the only product with a charger), while "do not separate label" indicates the widget multi-pack.
The workflow classifies the question, identifies the product being referenced (even from context clues), retrieves the customer's order history to confirm they actually purchased that product, then delivers specific product information—dimensions, usage instructions, warranty details—from a structured knowledge base.
Here's what makes this production-ready rather than a liability: every write operation runs in dry-run mode first. The AI executes the complete workflow, validates all the data, determines the correct actions, and then surfaces those actions for human approval before execution.
A refund operation appears in the unified inbox showing: "Operation 1: stripe:create_refund for $47.99 on charge ch_3abc123. Reason: Defective product reported within 30-day window. Operation 2: shopify:add_order_note documenting refund reason. Operation 3: reamaze:create_message sending refund confirmation to customer."
The governance team sees the complete action plan, verifies the logic, and approves with one click. The system then executes all three operations atomically—either all succeed or all fail, no partial states.
When customers need to add items to existing orders, we can't just create a new order—we need to charge them only for the new items while preserving the original order context.
The workflow creates a duplicate of the original order, applies a 100% discount to all original items (marked with reason: "Already Paid"), adds the new product at full price, calculates accurate shipping, generates a custom invoice, and sends it to the customer with context: "This invoice is for adding [Product] to your existing order 1234567. Original items are discounted since you've already paid."
This isn't RPA clicking through interfaces. This is an AI employee that understands "I didn't get my package" means: query Shopify for the order, parse the fulfillment data, check carrier tracking, evaluate shipment status, determine if it's lost versus delayed, and either provide accurate delivery information or initiate a lost package investigation.
It's labor that operates on the same information a human agent would use, makes the same decisions a trained agent would make, and executes through the same systems—just 3.4x faster, at 1/14th the cost, 24/7.
The workflows we built aren't impressive because they're complex. They're impressive because they're reliable. Every morning, the system wakes up, checks for new tickets, routes them to appropriate workflows, executes multi-step investigations and resolutions, and only escalates what genuinely requires human judgment.
That's not automation. That's employment.