<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: The Unmeshed Team</title>
    <description>The latest articles on DEV Community by The Unmeshed Team (@unmeshed).</description>
    <link>https://dev.to/unmeshed</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F3953781%2F5af20b0f-7da7-4490-9183-a2d28dab3978.png</url>
      <title>DEV Community: The Unmeshed Team</title>
      <link>https://dev.to/unmeshed</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/unmeshed"/>
    <language>en</language>
    <item>
      <title>Should You Take Orders When the Payment Gateway Is Down?</title>
      <dc:creator>The Unmeshed Team</dc:creator>
      <pubDate>Fri, 20 Nov 2026 11:03:06 +0000</pubDate>
      <link>https://dev.to/unmeshed/should-you-take-orders-when-the-payment-gateway-is-down-4akp</link>
      <guid>https://dev.to/unmeshed/should-you-take-orders-when-the-payment-gateway-is-down-4akp</guid>
      <description>&lt;p&gt;Black Friday is close, which means a lot of teams are about to find out which parts of their checkout they actually depend on.&lt;/p&gt;

&lt;p&gt;A typical order touches more systems than people expect. Inventory has to be reserved. Payment has to be authorized. A shipping label gets created. The confirmation email goes out. Somewhere on the page, a recommendation service suggests what else the customer might want. Each of those is a separate service, often run by a separate team or a separate company.&lt;/p&gt;

&lt;p&gt;Under normal traffic, all of them answer quickly and nobody thinks about the order they run in. Under peak traffic, one of them will slow down or fail. The useful question isn't whether that happens. It's whether your team has already decided what the order flow should do when it does, or whether that decision gets made at 2 a.m. by whoever is on call.&lt;/p&gt;

&lt;h2&gt;
  
  
  Not every step deserves the same treatment
&lt;/h2&gt;

&lt;p&gt;The easiest way to see this is to go through the order steps one at a time and ask a blunt question about each: if this fails, should the customer's order fail too?&lt;/p&gt;

&lt;p&gt;Recommendations are the easy case. If the recommendation service times out, show bestsellers or show nothing. Nobody has ever abandoned a purchase because the "you might also like" row was empty. This step should have a short timeout and permission to be skipped.&lt;/p&gt;

&lt;p&gt;The confirmation email is almost as easy. The order is real whether or not the email went out. If the email provider is struggling, queue the message and send it later. A confirmation that arrives twenty minutes late is fine. An order that failed because of an email is not.&lt;/p&gt;

&lt;p&gt;The shipping label can usually wait too. Labels are needed before the warehouse ships, not before the customer clicks "buy." If the carrier's API is overloaded, the order can be accepted and the label created once the API recovers.&lt;/p&gt;

&lt;p&gt;Inventory is where things get serious. If you can't confirm stock, you risk selling the same last unit to five people. Most teams treat a failed inventory reservation as a reason to stop the order, or at least to show a clear "can't confirm availability" message.&lt;/p&gt;

&lt;p&gt;And then there's payment.&lt;/p&gt;

&lt;h2&gt;
  
  
  The payment question
&lt;/h2&gt;

&lt;p&gt;If the payment gateway is down or timing out, you have roughly two options.&lt;/p&gt;

&lt;p&gt;You can fail the order. The customer sees an error and maybe tries again later. Your books stay clean, nobody gets goods they didn't pay for, and you lose some sales. On a day like Black Friday, a customer who hits an error often just buys from someone else.&lt;/p&gt;

&lt;p&gt;Or you can accept the order and hold the payment for retry. The customer sees "order received," the order sits in a pending state, and the system keeps trying to authorize the payment once the gateway recovers. You keep the sale, but you take on new problems. Some of those retries will fail because the card is declined, and now you have to contact a customer who thinks they've already bought something. Inventory reserved for a held order has to be released if the payment never goes through. Fraud checks that normally happen at checkout now happen after the fact.&lt;/p&gt;

&lt;p&gt;Neither option is free. The right answer depends on your margins, what you sell, how often your gateway actually has trouble, and how good your team is at cleaning up afterwards.&lt;/p&gt;

&lt;h2&gt;
  
  
  Writing the decision down
&lt;/h2&gt;

&lt;p&gt;Whatever you choose, the worst version is the one where the choice lives only inside scattered &lt;code&gt;try/catch&lt;/code&gt; blocks. At that point the behaviour during an outage is whatever the last person to touch the code happened to write.&lt;/p&gt;

&lt;p&gt;It helps to describe the order flow somewhere that makes each step's failure rule explicit. Here's an illustrative example. It's pseudo-config, not any specific tool's syntax.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;workflow&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;place_order&lt;/span&gt;
&lt;span class="na"&gt;steps&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
  &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;reserve_inventory&lt;/span&gt;
    &lt;span class="na"&gt;call&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;inventory.reserve&lt;/span&gt;
    &lt;span class="na"&gt;on_failure&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;fail_order&lt;/span&gt;

  &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;authorize_payment&lt;/span&gt;
    &lt;span class="na"&gt;call&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;payments.authorize&lt;/span&gt;
    &lt;span class="na"&gt;retry&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="s"&gt;max_attempts:&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;backoff:&lt;/span&gt; &lt;span class="s"&gt;exponential&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="na"&gt;on_failure&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;hold_for_retry&lt;/span&gt;   &lt;span class="c1"&gt;# or fail_order. This is the real decision.
&lt;/span&gt;
  &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;create_shipping_label&lt;/span&gt;
    &lt;span class="na"&gt;call&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;shipping.create_label&lt;/span&gt;
    &lt;span class="na"&gt;on_failure&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;retry_later&lt;/span&gt;

  &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;confirmation_email&lt;/span&gt;
    &lt;span class="na"&gt;call&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;email.send_confirmation&lt;/span&gt;
    &lt;span class="na"&gt;on_failure&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;retry_later&lt;/span&gt;

  &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;recommendations&lt;/span&gt;
    &lt;span class="na"&gt;call&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;recs.for_order&lt;/span&gt;
    &lt;span class="na"&gt;timeout&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;300ms&lt;/span&gt;
    &lt;span class="na"&gt;on_failure&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;skip&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The format matters less than the result. Anyone on the team can read this and know what happens when payments fail, without reading the payment service's code. If the business decides on Thursday night to switch from &lt;code&gt;hold_for_retry&lt;/code&gt; to &lt;code&gt;fail_order&lt;/code&gt;, that's one line, not a hunt through three services.&lt;/p&gt;

&lt;p&gt;The same file also shows which steps can safely fall behind. Retries for labels and emails can be held in a queue and worked through after the rush, so the slow parts of the system don't drag down the parts customers are waiting on.&lt;/p&gt;

&lt;h2&gt;
  
  
  Before the traffic arrives
&lt;/h2&gt;

&lt;p&gt;If you only do one thing this week, take your order flow and label every external call with one of three outcomes: fail the order, retry later, or skip. Then check that the code actually does what the label says. Gaps between the two tend to show up only under real load, which is the worst time to find them.&lt;/p&gt;

&lt;p&gt;It's also worth running a small drill. Point one dependency at a stub that times out, place a test order, and watch what happens. If nobody can predict the outcome before you try it, that's the step to sort out first.&lt;/p&gt;

&lt;h2&gt;
  
  
  So, what would you do?
&lt;/h2&gt;

&lt;p&gt;Back to the title. When the payment gateway is down during your busiest hour, do you fail the order or accept it and retry the payment later?&lt;/p&gt;

&lt;p&gt;If your team has lived through this, I'd like to know which way you went, whether you'd choose the same way again, and what the cleanup looked like afterwards.&lt;/p&gt;

</description>
      <category>discuss</category>
      <category>architecture</category>
      <category>webdev</category>
      <category>backend</category>
    </item>
    <item>
      <title>Meet Unmeshed: Run Your Apps, AI and People as One Workflow</title>
      <dc:creator>The Unmeshed Team</dc:creator>
      <pubDate>Thu, 19 Nov 2026 07:39:46 +0000</pubDate>
      <link>https://dev.to/unmeshed/meet-unmeshed-run-your-apps-ai-and-people-as-one-workflow-4cbi</link>
      <guid>https://dev.to/unmeshed/meet-unmeshed-run-your-apps-ai-and-people-as-one-workflow-4cbi</guid>
      <description>&lt;div&gt;
    &lt;iframe src="https://www.youtube.com/embed/Pgp6yTeHBtI" width="315" height="560"&gt;
    &lt;/iframe&gt;
  &lt;/div&gt;


&lt;p&gt;At most companies, work doesn’t live in one place. Part of it sits in the CRM, part of it runs as a cron job, some of it is a Python script someone wrote last year, and the rest depends on a manager or the finance team replying to a message.&lt;/p&gt;

&lt;p&gt;Most days, it holds together. But when one piece breaks, someone has to work out where it broke and fix it by hand.&lt;/p&gt;

&lt;p&gt;Unmeshed is a workflow orchestration platform. It takes all those pieces and runs them as one set of steps, in order. A step can be a bit of code, an AI model, a rules table, or a person.&lt;/p&gt;

&lt;p&gt;Take a simple expense approval. First, a step tidies up the claim. Then the workflow waits for a manager to approve it. That wait can last hours or even weeks, and the workflow won’t lose its place. Once the manager approves, the remaining steps run, everything turns green, and the whole run is saved in one record you can look back on.&lt;/p&gt;

&lt;p&gt;If a step fails along the way, Unmeshed retries it and picks up from where it stopped. It doesn’t start over from the beginning, and nobody has to go hunting for what went wrong.&lt;/p&gt;

&lt;p&gt;Unmeshed is built by the team that created Netflix Conductor, so this is a problem they’ve been working on for a long time.&lt;/p&gt;

&lt;p&gt;Your apps, your AI and your people, working as one workflow. &lt;br&gt;
Take a look: &lt;a href="https://unmeshed.io/" rel="noopener noreferrer"&gt;Unmeshed&lt;/a&gt;&lt;/p&gt;

</description>
      <category>automation</category>
      <category>tooling</category>
      <category>devops</category>
      <category>productivity</category>
    </item>
    <item>
      <title>Your AI Tools Work Fine on Their Own. Getting Them to Work Together Is the Hard Part</title>
      <dc:creator>The Unmeshed Team</dc:creator>
      <pubDate>Wed, 18 Nov 2026 06:40:50 +0000</pubDate>
      <link>https://dev.to/unmeshed/your-ai-tools-work-fine-on-their-own-getting-them-to-work-together-is-the-hard-part-2381</link>
      <guid>https://dev.to/unmeshed/your-ai-tools-work-fine-on-their-own-getting-them-to-work-together-is-the-hard-part-2381</guid>
      <description>&lt;p&gt;Most companies already run a lot of software. A payment system, a customer database, an email tool, and now a few AI assistants on top. Each one does its job well. The trouble starts when a task needs several of them, in the right order, every single time.&lt;/p&gt;

&lt;p&gt;That’s the problem this video is about. It explains it with four simple ideas.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;APIs&lt;/strong&gt; are how one app asks another app for something. Think of a waiter: they take your order to the kitchen and bring your food back. You never go into the kitchen yourself.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Workflows&lt;/strong&gt; are a set of tasks that happen in a fixed order to finish a job. Check this, then update that, then tell someone.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;AI agents&lt;/strong&gt; are AI that can understand a task, make a choice and take an action, within limits you set.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Orchestration&lt;/strong&gt; is what makes the other three work together. It’s the conductor keeping every musician in time. Each player knows their part, but someone has to make sure they come in at the right moment.&lt;/p&gt;

&lt;h3&gt;
  
  
  Where Unmeshed fits
&lt;/h3&gt;

&lt;p&gt;Unmeshed is the conductor. It isn’t another chatbot, and it isn’t an AI model. It connects to the apps and systems a business already uses and runs each step of a process in the right order.&lt;/p&gt;

&lt;p&gt;One workflow can include AI agents, code, business rules and people. If a step fails, Unmeshed can try it again, following rules your team sets. If something needs a person to look at it, the workflow pauses for approval and then carries on. And your team can see every step as it happens.&lt;/p&gt;

&lt;p&gt;That’s the difference between AI as an interesting experiment and AI a business can rely on every day.&lt;/p&gt;

&lt;h3&gt;
  
  
  What it looks like in practice
&lt;/h3&gt;

&lt;p&gt;Take something as ordinary as buying something online. Behind that one click, the payment is checked, the stock is confirmed, the warehouse gets the order, the delivery company is told and you get an update.&lt;/p&gt;

&lt;p&gt;Every one of those steps happens in a different system. If one message goes missing, the order gets stuck, and often nobody notices until the customer asks where their package is. With orchestration, each system does its part at the right moment, and if one is slow to respond, that step tries again instead of breaking the whole order.&lt;/p&gt;

&lt;p&gt;Most businesses don’t need more AI tools. They need the ones they already have to work together reliably. That’s what orchestration does.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://unmeshed.io/" rel="noopener noreferrer"&gt;Find out more about Unmeshed here.&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>automation</category>
      <category>architecture</category>
      <category>beginners</category>
    </item>
    <item>
      <title>Every Heist Needs a Mastermind. So Does Your Backend.</title>
      <dc:creator>The Unmeshed Team</dc:creator>
      <pubDate>Wed, 18 Nov 2026 06:13:37 +0000</pubDate>
      <link>https://dev.to/unmeshed/every-heist-needs-a-mastermind-so-does-your-backend-279h</link>
      <guid>https://dev.to/unmeshed/every-heist-needs-a-mastermind-so-does-your-backend-279h</guid>
      <description>&lt;div&gt;
    &lt;iframe src="https://www.youtube.com/embed/clDhGJ-sez0" width="315" height="560"&gt;
    &lt;/iframe&gt;
  &lt;/div&gt;


&lt;p&gt;Every app you use runs a small heist behind the scenes.&lt;/p&gt;

&lt;p&gt;Say you order a pair of shoes. One part of the system checks that the shoes are in stock. Another takes your payment. A third ships the box. Each one is a service, a small program with one job. Think of them as a crew: the inside guy, the safecracker and the driver.&lt;/p&gt;

&lt;p&gt;Now picture that crew with no plan. They just message each other and hope it works out. The stock check says yes, the payment is still pending, and the driver leaves anyway. Nobody notices anything went wrong until the customer calls asking about an order they were never charged for, or one that never showed up.&lt;/p&gt;

&lt;p&gt;Every heist needs a mastermind. In software, that’s called an orchestrator.&lt;/p&gt;

&lt;p&gt;The orchestrator holds the plan and tells each service when to move. The driver doesn’t leave until the payment clears. If the payment fails, it tries again. If it still fails, the shoes go back on the shelf so you don’t end up shipping something nobody paid for. And every move is written down, so when something goes wrong, you can see exactly what happened and when.&lt;/p&gt;

&lt;p&gt;That’s orchestration. It isn’t about making each service smarter. It’s about having one place that knows the whole plan.&lt;/p&gt;

&lt;p&gt;Unmeshed is the orchestrator for your backend. If your services are talking to each other and hoping for the best, take a look at how it works:&lt;br&gt;
&lt;a href="https://unmeshed.io/products/workflows" rel="noopener noreferrer"&gt;Unmeshed Workflows&lt;/a&gt;&lt;/p&gt;

</description>
      <category>architecture</category>
      <category>microservices</category>
      <category>backend</category>
      <category>beginners</category>
    </item>
    <item>
      <title>What Microsoft 365’s Friday the 13th outage teaches about waiting</title>
      <dc:creator>The Unmeshed Team</dc:creator>
      <pubDate>Tue, 17 Nov 2026 12:47:54 +0000</pubDate>
      <link>https://dev.to/unmeshed/what-microsoft-365s-friday-the-13th-outage-teaches-about-waiting-kio</link>
      <guid>https://dev.to/unmeshed/what-microsoft-365s-friday-the-13th-outage-teaches-about-waiting-kio</guid>
      <description>&lt;div&gt;
    &lt;iframe src="https://www.youtube.com/embed/wFlcAA5jPoU" width="315" height="560"&gt;
    &lt;/iframe&gt;
  &lt;/div&gt;
&lt;br&gt;
On Thursday, November 12, Outlook mailboxes in the Americas started failing a little after 11 a.m. Eastern. Within hours, Teams, Copilot, SharePoint and OneDrive were struggling too. Downdetector logged around 130,000 reports from 74 countries and territories. In the UK, some health services went back to paper records, and police asked people to call instead of email. Services didn't really start recovering until around midday on Friday the 13th. You couldn't write that date into a script without someone calling it lazy.

&lt;p&gt;We made a short video about it (above). This is the longer version: what broke, what Microsoft did about it, and the part most teams skip when they plan for outages.&lt;/p&gt;

&lt;h2&gt;
  
  
  What broke
&lt;/h2&gt;

&lt;p&gt;Microsoft ruled out an attack early on, calling it "a technical issue not related to cyber or AI / agents."&lt;/p&gt;

&lt;p&gt;The failure was a chain. Servers failed their automated health checks and dropped out of service. The servers left standing couldn't carry the load. A process that sets up secure connections got overwhelmed, so servers stopped answering requests. When engineers brought servers back, some failed again under live traffic, which pushed the overload onto whatever was left.&lt;/p&gt;

&lt;p&gt;When we made the video, Microsoft hadn't named a root cause. It has since said the trouble began with "an issue during an earlier network capacity upgrade that surfaced following a recent network change." In other words, a problem that sat quietly for a while, until something else changed around it. If you've run production systems for any length of time, that pattern will feel familiar.&lt;/p&gt;

&lt;h2&gt;
  
  
  How they brought it back
&lt;/h2&gt;

&lt;p&gt;The recovery is the most useful part of this story, because Microsoft described it as they went. They rebooted infrastructure, throttled traffic, rerouted around failures and added capacity. None of that is exotic. It's the standard playbook, applied carefully so that freshly restored servers didn't get flattened by all the traffic queued up behind them.&lt;/p&gt;

&lt;p&gt;One detail stood out. Delayed emails were held for up to 48 hours instead of being dropped. Mail that couldn't be delivered during the outage was kept and retried. That one decision is the difference between "email was slow on Thursday" and "we lost a day of customer messages."&lt;/p&gt;

&lt;h2&gt;
  
  
  The part most teams skip
&lt;/h2&gt;

&lt;p&gt;Every company plans for its own outages. Fewer plan for someone else's. Yet most workflows depend on services the team doesn't run: email, an identity provider, a payments API, a model endpoint. When one of those stops answering, the question isn't whether you'll be affected. It's what your workflow does while it waits.&lt;/p&gt;

&lt;p&gt;Usually the honest answer is that it hangs. A step calls a service, the service never answers, and the run just sits there. Nobody gets an error, so nobody does anything. Hours later, someone finds a pile of half-finished work and has to work out which parts actually happened.&lt;/p&gt;

&lt;p&gt;Three decisions fix most of this. They're cheap to make before an outage and expensive to make during one.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How long should this step wait?&lt;/strong&gt; Pick a number. "Forever" is also a choice, just a bad one.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What happens when the wait runs out?&lt;/strong&gt; Retry, fail loudly, or hand off to a backup process. Which one depends on the step. A notification can be retried later. A payment probably shouldn't be retried blindly.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What gets kept so nothing is lost?&lt;/strong&gt; Microsoft's 48-hour mail hold is a good model. If you can't finish the work now, store it and pick it up when the service is back.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where Unmeshed fits
&lt;/h2&gt;

&lt;p&gt;Unmeshed handles this at the step level. Every step in a workflow can have its own timeout, and when the timeout runs out, you choose what happens next: retry, fail, or run a backup process. That won't prevent outages. Nobody can promise that, not even Microsoft. What it does mean is that no step is left hanging forever while you wait for someone else's system to come back.&lt;/p&gt;

&lt;p&gt;Plan for the outage before it plans your Friday.&lt;/p&gt;

</description>
      <category>devops</category>
      <category>sre</category>
      <category>architecture</category>
      <category>microsoft</category>
    </item>
    <item>
      <title>Let AI Read the Claim. Don’t Let It Decide the Payout</title>
      <dc:creator>The Unmeshed Team</dc:creator>
      <pubDate>Tue, 17 Nov 2026 12:46:34 +0000</pubDate>
      <link>https://dev.to/unmeshed/let-ai-read-the-claim-dont-let-it-decide-the-payout-a9n</link>
      <guid>https://dev.to/unmeshed/let-ai-read-the-claim-dont-let-it-decide-the-payout-a9n</guid>
      <description>&lt;div&gt;
    &lt;iframe src="https://www.youtube.com/embed/BGhEwxULdPI" width="315" height="560"&gt;
    &lt;/iframe&gt;
  &lt;/div&gt;


&lt;p&gt;A claim comes in through a portal, an app or a phone call. Someone has to read the description, check the policy, work out what’s covered, calculate the payout and decide whether anything looks off. Most of that work is the same for every claim, and it’s slow when people do it by hand.&lt;/p&gt;

&lt;p&gt;So it’s tempting to hand the whole thing to an AI model. The trouble is that a model can give a different answer to the same claim on a different day, and nobody can fully explain why it paid what it paid. That’s a hard thing to defend to a customer, an auditor or a regulator.&lt;/p&gt;

&lt;p&gt;We built a claims workflow in Unmeshed that splits the work up.&lt;/p&gt;

&lt;p&gt;When a claim arrives, the workflow first checks that it has a policy number, a date of loss and a claim type. If anything is missing, it goes back to intake before any other step runs. Then it pulls the live policy details, and AI reads the claimant’s description to pull out the loss amount and what kind of loss it is.&lt;/p&gt;

&lt;p&gt;From there, AI steps back. Coverage is decided by a rule table that your underwriting team owns. The payout is plain arithmetic: the loss or the coverage limit, whichever is lower, minus the deductible. The same claim gets the same answer every time.&lt;/p&gt;

&lt;p&gt;AI does come back in once more, to look for anything in the claim that doesn’t add up. It can flag a claim, but it can’t reject one. A high fraud risk always sends the claim to a person.&lt;/p&gt;

&lt;p&gt;Simple, low-risk claims settle on their own, and the claimant gets an email showing the loss, the deductible and the payout. Anything flagged, high value or uncertain goes to an adjuster with an AI-written summary, clearly marked as a draft, next to the real numbers. Nothing is paid until the adjuster approves.&lt;/p&gt;

&lt;p&gt;And every decision is logged before any money moves.&lt;/p&gt;

&lt;p&gt;Setup takes about 25 minutes. &lt;a href="https://unmeshed.io/templates/claims-automation-fnol-to-settlement" rel="noopener noreferrer"&gt;Grab the template here.&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>automation</category>
      <category>insurtech</category>
      <category>workflow</category>
    </item>
    <item>
      <title>Your Integration Code Is Already a Workflow</title>
      <dc:creator>The Unmeshed Team</dc:creator>
      <pubDate>Mon, 16 Nov 2026 05:32:56 +0000</pubDate>
      <link>https://dev.to/unmeshed/your-integration-code-is-already-a-workflow-1fnk</link>
      <guid>https://dev.to/unmeshed/your-integration-code-is-already-a-workflow-1fnk</guid>
      <description>&lt;p&gt;If you've worked on backend code for a while, you've probably met a function like this. It started small, it works, and nobody wants to touch it.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="k"&gt;async&lt;/span&gt; &lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;handleLabOrder&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;order&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;labRef&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="n"&gt;labApi&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;submit&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;order&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;results&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="nf"&gt;pollUntilReady&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;labRef&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="n"&gt;ehr&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;updateRecord&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;order&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;patientId&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;results&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

  &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;results&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;abnormal&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="nf"&gt;notifyDoctor&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;order&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;doctorId&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;results&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;

  &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="n"&gt;billing&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;createInvoice&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;order&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This one handles a hospital lab order. It sends the test to the lab, waits for the results, saves them to the patient's record, alerts the doctor if something looks wrong, and creates the bill. That's five steps across four outside systems, written as ten lines that read neatly from top to bottom.&lt;/p&gt;

&lt;p&gt;On a good day it does exactly what it says. The trouble is that these steps don't run in seconds. The lab might take an hour. The doctor might not look until the next morning. Any of the four systems can be down at the moment you call it. A function expects to run from start to finish in one go, and this process doesn't work that way.&lt;/p&gt;

&lt;p&gt;So this isn't really a function. It's a long-running workflow squeezed into the shape of one, and that mismatch causes most of the trouble that comes later.&lt;/p&gt;

&lt;h2&gt;
  
  
  Questions this code can't answer
&lt;/h2&gt;

&lt;p&gt;Ask it a few ordinary questions and the gaps show up quickly.&lt;/p&gt;

&lt;p&gt;What happens if the process restarts while &lt;code&gt;pollUntilReady&lt;/code&gt; is running? The lab already has the order, but your process has forgotten it. Either the order is lost, or the retry submits it a second time.&lt;/p&gt;

&lt;p&gt;Where does the code wait while the doctor reviews abnormal results? It doesn't. &lt;code&gt;notifyDoctor&lt;/code&gt; sends a message and moves straight on to billing. The review only exists in someone's head.&lt;/p&gt;

&lt;p&gt;A nurse asks where order #4821 is right now. To answer, someone has to search logs across four services and hope the IDs match up.&lt;/p&gt;

&lt;p&gt;Billing switches vendors next quarter. That means changing this function, plus every other function that copied the same invoice call.&lt;/p&gt;

&lt;p&gt;None of these are rare edge cases. They're normal days for any process that touches several systems and involves people.&lt;/p&gt;

&lt;h2&gt;
  
  
  How it usually gets patched
&lt;/h2&gt;

&lt;p&gt;Teams tend to fix these one incident at a time. A retry wrapper goes around the lab call. A status column appears on the orders table. A cron job checks for orders stuck longer than an hour, and a Slack alert fires when it finds one.&lt;/p&gt;

&lt;p&gt;Each fix makes sense on its own. Add them up, though, and the real workflow ends up spread across a function, a database column, a cron job, and a chat channel. Drawing the full process on a whiteboard now means opening three repos first.&lt;/p&gt;

&lt;p&gt;At that point it helps to call the code what it is: a sequence of steps with state, waiting, failures, and people in the middle. That kind of thing works better when it's treated as a workflow on purpose.&lt;/p&gt;

&lt;h2&gt;
  
  
  The same logic as a workflow
&lt;/h2&gt;

&lt;p&gt;Here's the same process written as a workflow definition. It's illustrative pseudo-config, not the syntax of any particular tool.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;workflow&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;lab_order&lt;/span&gt;
&lt;span class="na"&gt;steps&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
  &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;submit_to_lab&lt;/span&gt;
    &lt;span class="na"&gt;call&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;lab.submit&lt;/span&gt;
    &lt;span class="na"&gt;retry&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="s"&gt;max_attempts:&lt;/span&gt; &lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;backoff:&lt;/span&gt; &lt;span class="s"&gt;exponential&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;

  &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;wait_for_results&lt;/span&gt;
    &lt;span class="na"&gt;wait_for_event&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;lab.results_ready&lt;/span&gt;
    &lt;span class="na"&gt;timeout&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;24h&lt;/span&gt;

  &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;update_record&lt;/span&gt;
    &lt;span class="na"&gt;call&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;ehr.update_record&lt;/span&gt;

  &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;doctor_review&lt;/span&gt;
    &lt;span class="na"&gt;when&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;results.abnormal&lt;/span&gt;
    &lt;span class="na"&gt;human_task&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
      &lt;span class="na"&gt;assign_to&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;order.doctor_id&lt;/span&gt;
      &lt;span class="na"&gt;timeout&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;8h&lt;/span&gt;
      &lt;span class="na"&gt;on_timeout&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;escalate_to_on_call&lt;/span&gt;

  &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;create_invoice&lt;/span&gt;
    &lt;span class="na"&gt;call&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;billing.create_invoice&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The business logic hasn't changed. What changes is who handles everything around it.&lt;/p&gt;

&lt;p&gt;Progress is saved after each step, outside your process. If something crashes during &lt;code&gt;wait_for_results&lt;/code&gt;, the run picks up there instead of sending the order to the lab again.&lt;/p&gt;

&lt;p&gt;Waiting becomes a normal step. Waiting a day for the lab or eight hours for a doctor is written into the flow, with a timeout, instead of living in a polling loop someone has to maintain.&lt;/p&gt;

&lt;p&gt;The doctor's review gets an owner, a deadline, and an escalation path. It stops being a notification that nobody follows up on.&lt;/p&gt;

&lt;p&gt;Finding order #4821 becomes a lookup, because the engine knows which step every run is on.&lt;/p&gt;

&lt;p&gt;Changing billing vendors means editing one step. Adding something new, such as an AI step that summarizes abnormal results for the doctor, means adding one more step rather than rewriting the function.&lt;/p&gt;

&lt;h2&gt;
  
  
  When it isn't worth it
&lt;/h2&gt;

&lt;p&gt;Plenty of code should stay a plain function. If the steps finish in milliseconds, the calls are safe to repeat, nobody waits on a person, and a failure can just be retried from the top, a workflow engine is extra infrastructure you don't need. A two-step script that runs once a night doesn't need a flowchart.&lt;/p&gt;

&lt;p&gt;A rough test: if you've already added a status column, a cron job that hunts for stuck items, or an admin button that says "retry from step 3," you've built half a workflow engine by hand. The remaining question is whether you want to keep maintaining it yourself.&lt;/p&gt;

&lt;h2&gt;
  
  
  Code or config?
&lt;/h2&gt;

&lt;p&gt;Once teams decide to treat a process as a workflow, they usually split into two camps.&lt;/p&gt;

&lt;p&gt;One camp writes workflows as code. Steps are ordinary functions, and the engine handles saving progress and retries behind the scenes. You keep your usual language, type checking, and tests.&lt;/p&gt;

&lt;p&gt;The other camp writes workflows as data, like the YAML above. You get a diagram that people outside engineering can read, changes that don't always need a deploy, and a clear picture of where each run stands. The risk is that a large definition can turn into a config file nobody wants to open.&lt;/p&gt;

&lt;p&gt;Both approaches have tradeoffs, and teams land differently depending on who needs to read and change the flow.&lt;/p&gt;

&lt;p&gt;So which one does your team use, and what pushed you that way? If you've seen a workflow-as-data setup grow into an unreadable YAML file, I'd like to hear how you got out of it.&lt;/p&gt;

</description>
      <category>discuss</category>
      <category>architecture</category>
      <category>backend</category>
      <category>programming</category>
    </item>
    <item>
      <title>Your API Call Doesn't Need a Save Point</title>
      <dc:creator>The Unmeshed Team</dc:creator>
      <pubDate>Fri, 13 Nov 2026 06:31:34 +0000</pubDate>
      <link>https://dev.to/unmeshed/your-api-call-doesnt-need-a-save-point-2kb1</link>
      <guid>https://dev.to/unmeshed/your-api-call-doesnt-need-a-save-point-2kb1</guid>
      <description>&lt;p&gt;Open a banking app and the home screen loads in a blink. Behind it, one request quietly asks three systems for your account balance, your recent transactions, and the offers you qualify for.&lt;/p&gt;

&lt;p&gt;Now think about a loan application. It takes two days. It waits on documents, a credit check and a person's approval, and it must never lose its place if a server restarts.&lt;/p&gt;

&lt;p&gt;Both are workflows. They need opposite things.&lt;/p&gt;

&lt;p&gt;What "remembering every step" costs&lt;/p&gt;

&lt;p&gt;A loan application needs a save point after every step. If something breaks, it resumes right where it stopped. That's the job of a durable workflow engine, and it's worth the price. Saving state takes time, and for a two-day process, nobody notices.&lt;/p&gt;

&lt;p&gt;A home screen is different. Nobody is going to resume it tomorrow. The user is staring at a spinner right now, so every millisecond spent writing down "step two finished" is a millisecond they wait for nothing. If the request fails, the app just asks again.&lt;/p&gt;

&lt;p&gt;The point isn't that saving state is bad. It's that it should match the job.&lt;/p&gt;

&lt;p&gt;What a fast API workflow needs&lt;/p&gt;

&lt;p&gt;For the short, user-facing kind, the list is different from a back-office process:&lt;/p&gt;

&lt;p&gt;Answers in milliseconds. The person is waiting.&lt;br&gt;
Partial results. Send the balance as soon as it arrives instead of holding everything until the slowest call returns.&lt;br&gt;
Parallel calls. Ask all three systems at once, not one after another.&lt;br&gt;
Security built in. API key authentication and rate limiting, since these calls face the outside world.&lt;br&gt;
Fan-out in practice&lt;/p&gt;

&lt;p&gt;Take that home screen. One incoming request fans out: account data from one system, recent transactions from another, current offers from a third. The workflow gathers the three answers, reshapes them into the format the app expects, and returns one response.&lt;/p&gt;

&lt;p&gt;Total wait is roughly the slowest of the three calls, not the sum of all three. That's the whole reason to fan out.&lt;/p&gt;

&lt;p&gt;So which kind do you have?&lt;/p&gt;

&lt;p&gt;Ask two questions. If this fails halfway, does someone need it to resume where it stopped, or can the caller just retry? And how long is a human waiting?&lt;/p&gt;

&lt;p&gt;If a failure means money in limbo or a process that has to finish, keep the state. If it's a quick read that someone is watching load, keep it light. Most systems have both kinds, and the mistake is using one setup for everything.&lt;/p&gt;

&lt;p&gt;Unmeshed says it's built to handle both: short API-driven flows and long-running backend processes on the same platform.&lt;/p&gt;

</description>
      <category>api</category>
      <category>architecture</category>
      <category>backend</category>
      <category>performance</category>
    </item>
    <item>
      <title>When Your Workflow Needs Just a Little Code</title>
      <dc:creator>The Unmeshed Team</dc:creator>
      <pubDate>Thu, 12 Nov 2026 11:17:16 +0000</pubDate>
      <link>https://dev.to/unmeshed/when-your-workflow-needs-just-a-little-code-16ef</link>
      <guid>https://dev.to/unmeshed/when-your-workflow-needs-just-a-little-code-16ef</guid>
      <description>&lt;div&gt;
    &lt;iframe src="https://www.youtube.com/embed/RZmOZlpqEz8" width="315" height="560"&gt;
    &lt;/iframe&gt;
  &lt;/div&gt;


&lt;p&gt;Most workflows are mostly simple. Call an API, wait for a reply, send a message. But every now and then, you need a few lines of code in the middle. Maybe you need to filter a list, reshape some data, or check a value before moving on.&lt;/p&gt;

&lt;p&gt;That’s when things get annoying. For ten lines of code, you end up setting up a separate service, hosting it somewhere, and wiring it back into your workflow. Now you have one more thing to deploy and keep running.&lt;/p&gt;

&lt;p&gt;In Unmeshed, you can write that code right inside the workflow as its own step. Pick JavaScript or Python (Go works too), write what you need, and it runs as part of the flow. The step can use the output from the steps before it and pass its result to the next one. There’s no extra server to manage. Unmeshed runs the code for you.&lt;/p&gt;

&lt;p&gt;For bigger jobs, like heavy processing or anything that needs your own setup, you can run that work on your own servers and still keep it in the same workflow.&lt;/p&gt;

&lt;p&gt;So the small stuff stays quick and simple, and the big stuff runs where it makes sense.&lt;/p&gt;

&lt;p&gt;Want to try it? Learn more about code steps here:&lt;br&gt;
&lt;a href="https://unmeshed.io/product/whats-new/hosted-functions" rel="noopener noreferrer"&gt;Hosted Functions - Unmeshed&lt;/a&gt;&lt;/p&gt;

</description>
      <category>javascript</category>
      <category>python</category>
      <category>automation</category>
      <category>webdev</category>
    </item>
    <item>
      <title>Workflow Steps Shouldn’t Run Without a Human Saying Yes</title>
      <dc:creator>The Unmeshed Team</dc:creator>
      <pubDate>Wed, 11 Nov 2026 10:04:27 +0000</pubDate>
      <link>https://dev.to/unmeshed/workflow-steps-shouldnt-run-without-a-human-saying-yes-2115</link>
      <guid>https://dev.to/unmeshed/workflow-steps-shouldnt-run-without-a-human-saying-yes-2115</guid>
      <description>&lt;div&gt;
    &lt;iframe src="https://www.youtube.com/embed/epo_PelMA94" width="315" height="560"&gt;
    &lt;/iframe&gt;
  &lt;/div&gt;


&lt;p&gt;Most of a workflow can run on its own. Fetch the data, process it, call the next API. But some steps need a person to look first: a large refund, a loan application, a deployment to production, an AI agent about to take an action you can’t undo.&lt;/p&gt;

&lt;p&gt;Teams usually handle this outside the workflow. Someone gets a Slack message or an email, approves it somewhere else, and then another person restarts the process by hand. That works until the approver is on leave, the message gets buried, and the workflow sits there waiting with nobody noticing.&lt;/p&gt;

&lt;p&gt;With Unmeshed, the approval is a step inside the workflow itself.&lt;br&gt;
When the workflow reaches a step that needs a decision, it pauses and sends the request to the right person or team. They respond through a form, so the workflow gets a clear, structured answer and not a “looks fine” in a chat thread. Unmeshed checks that answer, and if it’s valid, the workflow picks up where it stopped and carries on to the next step. If the input is missing or wrong, it goes back for another try.&lt;/p&gt;

&lt;p&gt;And if nobody responds in time, the task doesn’t just sit there. It can be escalated or reassigned to someone else, and your support or ops team can get an alert.&lt;/p&gt;

&lt;p&gt;Every decision is recorded, so you always know who approved what and when. The approval stays part of the workflow’s history, not a message someone has to dig up later.&lt;/p&gt;

&lt;p&gt;Explore the Human-in-the-Loop Approvals template here.&lt;/p&gt;

</description>
      <category>automation</category>
      <category>devops</category>
      <category>ai</category>
      <category>tooling</category>
    </item>
    <item>
      <title>Not Every Signup Is a Real Lead. Here’s How to Spot the Ones That Are</title>
      <dc:creator>The Unmeshed Team</dc:creator>
      <pubDate>Tue, 10 Nov 2026 10:39:52 +0000</pubDate>
      <link>https://dev.to/unmeshed/not-every-signup-is-a-real-lead-heres-how-to-spot-the-ones-that-are-eaa</link>
      <guid>https://dev.to/unmeshed/not-every-signup-is-a-real-lead-heres-how-to-spot-the-ones-that-are-eaa</guid>
      <description>&lt;p&gt;A walkthrough of the workflow in the video: Hunter.io, Kickbox, Postgres and Slack, and why it’s built in this order&lt;br&gt;
  &lt;/p&gt;
&lt;div&gt;
    &lt;iframe src="https://www.youtube.com/embed/aNsmn7X-au4" width="315" height="560"&gt;
    &lt;/iframe&gt;
  &lt;/div&gt;
&lt;br&gt;
Someone signs up on your site. You get a name and an email, and not much else. Is it a real business lead, or someone who used a throwaway address just to get past the form?

&lt;p&gt;Most teams find out by checking each signup by hand. They look up the company, check the email and decide whether it’s worth a call. That works when there are ten signups a day. When there are hundreds, good leads sit in the database and nobody notices them.&lt;/p&gt;

&lt;p&gt;We built a workflow in Unmeshed that does this checking for you.&lt;/p&gt;

&lt;p&gt;When a new signup comes in, it checks that the email and name look right, then saves the person to your database straight away. After that, Hunter.io finds the company behind the email and how many people work there, and Kickbox checks whether the address is a free or throwaway one.&lt;/p&gt;

&lt;p&gt;A work email at a real company is marked high value, and your team gets a Slack alert. A Gmail or disposable address is marked low value. Either way, every signup is saved with its company details, so you can always go back to it.&lt;/p&gt;

&lt;p&gt;And if one of the lookup tools is down, the signup is still saved. A lead shouldn’t get lost just because an outside service had a bad day.&lt;/p&gt;

&lt;p&gt;Setup takes about 15 minutes. &lt;a href="https://unmeshed.io/templates/signup-lead-enrichment-classification-routing" rel="noopener noreferrer"&gt;Grab the template here.&lt;/a&gt;&lt;/p&gt;

</description>
      <category>automation</category>
      <category>webdev</category>
      <category>saas</category>
      <category>productivity</category>
    </item>
    <item>
      <title>AI Agents for Business: 10 Examples That Work Today</title>
      <dc:creator>The Unmeshed Team</dc:creator>
      <pubDate>Tue, 10 Nov 2026 05:44:38 +0000</pubDate>
      <link>https://dev.to/unmeshed/ai-agents-for-business-10-examples-that-work-today-5bf3</link>
      <guid>https://dev.to/unmeshed/ai-agents-for-business-10-examples-that-work-today-5bf3</guid>
      <description>&lt;h2&gt;
  
  
  TLDR
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Ten companies- Klarna, Zendesk, Spellbook, EvenUp, Qonto, Carvana, DXC, Atlassian, Supermetrics, and GitHub- show what AI agents do in daily work today.&lt;/li&gt;
&lt;li&gt;Every number is the company's own claim, and nobody audited it. Klarna's figures date from February 2024.&lt;/li&gt;
&lt;li&gt;The bike analogy sorts agents by how much they do alone, from suggesting, to acting after approval, to acting within limits.&lt;/li&gt;
&lt;li&gt;The agents that work keep a person at the point of consequence, so someone approves, signs, or turns things live.&lt;/li&gt;
&lt;li&gt;Unmeshed runs the steps around your agents, with approval steps, retries, durable runs, and a log of every step. We don't build the agent or the model.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;AI agents for business get talked about a lot and shown very little. Most posts say agents will "transform" support or finance and then stop, which gives you nothing to act on.&lt;/p&gt;

&lt;p&gt;So we did it differently. We picked ten companies that run agents in daily work and read what each one says about the job, the result, and who still checks the work. Every number below comes from the company itself. Nobody audited them, and we haven't run any of these agents ourselves. Klarna's figures date from its February 2024 launch post, so read them as a snapshot.&lt;/p&gt;

&lt;p&gt;One idea runs through all ten. Think about learning to ride a bike. You start with training wheels, then a parent jogs behind you, then you ride alone. Companies treat AI agents for business the same way, and they pick the stage based on how bad a fall would be.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fpdcrowl7mm3y1em2t2jj.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fpdcrowl7mm3y1em2t2jj.jpg" alt="Think of AI autonomy like learning to ride a bike. First, the agent suggests and drafts while a person handles the final action. Then it starts acting with approval at each step. Eventually, it can operate within set limits, with people reviewing the results afterward. As trust grows, teams can gradually reduce the need for approvals." width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;We build workflow software, so we'll say where Unmeshed fits near the end. Okay, let's get into it.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. What Are AI Agents for Business?
&lt;/h2&gt;

&lt;p&gt;AI agents for business are software that takes a goal, plans the steps, uses your tools, checks the result, and adjusts. A chatbot answers a question. An agent files the ticket, updates the record, or drafts the contract. A person still sets the limits and reviews the work.&lt;/p&gt;

&lt;p&gt;GitHub puts it well in its docs on Copilot agents. An agent can search a repository, edit code, run tests, and revise its changes when a test fails. It decides the steps instead of only returning an answer.&lt;/p&gt;

&lt;p&gt;Here's how the three terms people mix up compare.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Term&lt;/th&gt;
&lt;th&gt;What It Does&lt;/th&gt;
&lt;th&gt;Who Picks the Steps&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Chat&lt;/td&gt;
&lt;td&gt;Answers questions and takes direction in a back-and-forth&lt;/td&gt;
&lt;td&gt;You&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Fixed automation&lt;/td&gt;
&lt;td&gt;Runs the same steps when an event or schedule triggers it&lt;/td&gt;
&lt;td&gt;Whoever built it&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Agent&lt;/td&gt;
&lt;td&gt;Works toward a goal, uses tools, and adapts to what happens&lt;/td&gt;
&lt;td&gt;The agent, within the limits you set&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;If you want the longer version of how agents get coordinated, we cover it in our post on agentic orchestration.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. What Can AI Agents Do for Your Business?
&lt;/h2&gt;

&lt;p&gt;AI agents for business can answer customers, review documents, draft work for a person to check, prepare financial tasks, investigate alerts, and manage campaigns. How much they do alone varies. Some only suggest, some act after approval, and some run alone within set limits.&lt;/p&gt;

&lt;p&gt;That's the bike again. Training wheels means the agent suggests and a person does the work. The jogging parent means the agent acts and a person approves each move. Riding alone means the agent acts within limits and a person reviews afterward.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Stage&lt;/th&gt;
&lt;th&gt;What the Agent Does&lt;/th&gt;
&lt;th&gt;Where the Person Is&lt;/th&gt;
&lt;th&gt;Example Below&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Training wheels&lt;/td&gt;
&lt;td&gt;Suggests and drafts&lt;/td&gt;
&lt;td&gt;Does the final work&lt;/td&gt;
&lt;td&gt;Spellbook, EvenUp&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Parent jogging behind&lt;/td&gt;
&lt;td&gt;Acts after approval&lt;/td&gt;
&lt;td&gt;Approves each action&lt;/td&gt;
&lt;td&gt;Qonto, Supermetrics&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Riding alone&lt;/td&gt;
&lt;td&gt;Acts inside set limits&lt;/td&gt;
&lt;td&gt;Reviews afterward&lt;/td&gt;
&lt;td&gt;Klarna, Carvana&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Nobody stays at one stage forever. A team might start with approvals on everything and loosen them as the agent earns trust. That takes good plumbing underneath, which is what AI orchestration is for.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. What Are 10 AI Agent Examples That Work Today?
&lt;/h2&gt;

&lt;p&gt;Ten companies run AI agents for business in daily work today. They are Klarna, Zendesk, Spellbook, EvenUp, Qonto, Carvana, DXC, Atlassian, Supermetrics, and GitHub. Each one below says what the agent does, what the company reports, and where a person stays involved. All numbers come from the companies themselves.&lt;/p&gt;

&lt;p&gt;This is the quick view before we go one by one. These AI agent examples cover support, legal, finance, engineering, insurance, and marketing.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Company&lt;/th&gt;
&lt;th&gt;Job&lt;/th&gt;
&lt;th&gt;Person's Role&lt;/th&gt;
&lt;th&gt;Company Reported&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Klarna&lt;/td&gt;
&lt;td&gt;Customer service chats&lt;/td&gt;
&lt;td&gt;Handles what the agent can't&lt;/td&gt;
&lt;td&gt;Two-thirds of chats in month one&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Zendesk&lt;/td&gt;
&lt;td&gt;Customer-built service agents&lt;/td&gt;
&lt;td&gt;Picks which actions are allowed&lt;/td&gt;
&lt;td&gt;1 million executions in 7 weeks&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Spellbook&lt;/td&gt;
&lt;td&gt;Contract review&lt;/td&gt;
&lt;td&gt;Lawyer decides the edits&lt;/td&gt;
&lt;td&gt;About 530,000 reviews a month&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;EvenUp&lt;/td&gt;
&lt;td&gt;Legal demand drafts&lt;/td&gt;
&lt;td&gt;Attorney signs every draft&lt;/td&gt;
&lt;td&gt;8 to 15 hours down to minutes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Qonto&lt;/td&gt;
&lt;td&gt;Payroll, transfers, invoices&lt;/td&gt;
&lt;td&gt;Customer approves&lt;/td&gt;
&lt;td&gt;Payroll 5X faster&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Carvana&lt;/td&gt;
&lt;td&gt;Production alerts&lt;/td&gt;
&lt;td&gt;Engineer reviews the fix&lt;/td&gt;
&lt;td&gt;56 percent fewer alerts in one channel&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;DXC&lt;/td&gt;
&lt;td&gt;Insurance claims&lt;/td&gt;
&lt;td&gt;Experts own the checkpoints&lt;/td&gt;
&lt;td&gt;Backlogs from days to minutes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Atlassian&lt;/td&gt;
&lt;td&gt;Team workflow agents&lt;/td&gt;
&lt;td&gt;Customers set what agents touch&lt;/td&gt;
&lt;td&gt;5 million plus agents a month&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Supermetrics&lt;/td&gt;
&lt;td&gt;Ad campaigns&lt;/td&gt;
&lt;td&gt;Human turns campaigns live&lt;/td&gt;
&lt;td&gt;10-hour report in 20 minutes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GitHub&lt;/td&gt;
&lt;td&gt;Code changes&lt;/td&gt;
&lt;td&gt;Reviewer merges the pull request&lt;/td&gt;
&lt;td&gt;Opens pull requests for review&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h3&gt;
  
  
  1. Klarna Handles Customer Service Chats
&lt;/h3&gt;

&lt;p&gt;Klarna's AI assistant handled 2.3 million conversations in its first month, two-thirds of its customer service chats, which Klarna says equals the work of 700 full-time agents. It runs in 23 markets and over 35 languages. Klarna reports satisfaction on par with human agents, per its launch announcement.&lt;/p&gt;

&lt;p&gt;Klarna also says repeat inquiries fell 25 percent and resolution time dropped from 11 minutes to under 2. The assistant runs on OpenAI, and these are February 2024 figures, so check for newer ones before you quote them.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Zendesk Lets Customers Build Their Own Service Agents
&lt;/h3&gt;

&lt;p&gt;Zendesk built custom agents on Claude and reports 1 million agent executions in the first 7 weeks of early access, with up to 80 percent lower human handle times. Customers choose which actions each agent may take, so the limits sit with the company using it, per Zendesk's story.&lt;/p&gt;

&lt;p&gt;One example is incident triage. The agent files a Jira issue and posts in Slack. That's a small job with a clear edge, which is why it works.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Spellbook Reviews Contracts
&lt;/h3&gt;

&lt;p&gt;Spellbook says its agents handle about 530,000 contract reviews a month, cutting some reviews from about 10 hours to about one. Edits stay confined to the paragraphs the user specifies, and data is not retained. The lawyer still decides what goes into the contract, per Spellbook's story.&lt;/p&gt;

&lt;p&gt;Notice the guardrail. The agent can't wander through the whole document. It touches what you point at.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. EvenUp Drafts Legal Demand Packages
&lt;/h3&gt;

&lt;p&gt;EvenUp uses AI to draft personal injury demand packages that took 8 to 15 hours and now take minutes, according to the company. An attorney reads, checks, and signs every draft, and every fact is cited to a page in the source records, per EvenUp's story.&lt;/p&gt;

&lt;p&gt;The speed is the headline, but the citation is the part that makes it usable. A lawyer can check a fact in seconds when it points to a page.&lt;/p&gt;

&lt;h3&gt;
  
  
  5. Qonto Prepares Payroll, Transfers, and Invoices
&lt;/h3&gt;

&lt;p&gt;Qonto's agents prepare payroll, transfers, and invoices, and the customer approves each one. Qonto reports transfers 2X faster, invoices 3X, and payroll 5X. Transfers up to 100,000 euros can be delegated. The agent prepares and recommends, and the user decides, per Qonto's story.&lt;/p&gt;

&lt;p&gt;It's built on an MCP server, which is how the agent reaches Qonto's tools. We explain that piece in our post on MCP.&lt;/p&gt;

&lt;h3&gt;
  
  
  6. Carvana Investigates Production Alerts
&lt;/h3&gt;

&lt;p&gt;Carvana uses Claude Tag in Slack to investigate production alerts, find the owning team, and post a root cause write-up before an engineer starts. Carvana reports 56 percent fewer alerts in one channel and 65 percent faster answers for another team, per Carvana's story.&lt;/p&gt;

&lt;p&gt;Fixes still go through a pull request and human review. One team gave the agent read-only access to the same tools an on-call engineer would use. That's a sensible first step.&lt;/p&gt;

&lt;h3&gt;
  
  
  7. DXC Reads Insurance Claims
&lt;/h3&gt;

&lt;p&gt;DXC uses Claude to classify insurance claim documents in under a second and says backlogs dropped from days to minutes. Agents work inside set authority levels, humans own checkpoints on material calls, and every action is logged so a regulator can replay it, per DXC's story.&lt;/p&gt;

&lt;p&gt;DXC also says it built a workers' compensation calculation in 8 hours that was 80 percent right on the first pass. Claims experts handle the other 20 percent.&lt;/p&gt;

&lt;h3&gt;
  
  
  8. Atlassian Runs Agents Inside Team Workflows
&lt;/h3&gt;

&lt;p&gt;Atlassian says more than 5 million agents run in customer business workflows each month, handling work like triaging support tickets, reviewing contracts, and surfacing sales leads. It uses different models for different jobs, with lighter ones for high-volume agents and Claude for long, complex tasks, per Atlassian's story.&lt;/p&gt;

&lt;p&gt;In its early access Rovo Max mode, admins control the packages and network access the agent can use. Same idea again. The agent works, and someone else sets the fence.&lt;/p&gt;

&lt;h3&gt;
  
  
  9. Supermetrics Manages Ad Campaigns From a Chat
&lt;/h3&gt;

&lt;p&gt;Supermetrics lets marketers ask questions of live ad data in Claude and then create or edit campaigns across six ad platforms. New campaigns start paused, and approval levels are set per account. One agency customer reports a 10-hour client report now takes 20 minutes, per Supermetrics' story.&lt;/p&gt;

&lt;p&gt;A paused campaign is a simple trick. The agent does the setup, and nothing spends money until a person flips it on.&lt;/p&gt;

&lt;h3&gt;
  
  
  10. GitHub Copilot Opens Pull Requests
&lt;/h3&gt;

&lt;p&gt;GitHub's Copilot cloud agent researches a repository, makes changes on a branch, and opens a pull request for a person to review. GitHub describes three modes, collaborative, asynchronous, and automated, and says you stay responsible for the goal, the access, and the review, per GitHub's docs.&lt;/p&gt;

&lt;p&gt;This one isn't built on Claude, which is the point. The pattern holds across vendors.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. What Do Working Agentic AI Examples Have in Common?
&lt;/h2&gt;

&lt;p&gt;Working agentic AI examples share four traits. The job is narrow, the agent uses tools, a person approves at the point of consequence, and every action leaves a record. Qonto, EvenUp, Supermetrics, and DXC all show it. The pattern matters more than any single number.&lt;/p&gt;

&lt;p&gt;Here they are in plain words.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;A narrow job:&lt;/strong&gt; Triage this alert. Review this contract. Prepare this payroll. Nobody told an agent to run the company.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Working tools:&lt;/strong&gt; The agent files the Jira issue and opens the pull request. It does the work, and talks too.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A person at the point of consequence:&lt;/strong&gt; Qonto's customer approves, EvenUp's attorney signs, and Supermetrics starts campaigns paused.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A record:&lt;/strong&gt; DXC logs every action so a regulator can replay it. Carvana's fixes land in a pull request anyone can read.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ft5xzck5ldcj26ujidnnk.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ft5xzck5ldcj26ujidnnk.jpg" alt="What makes an AI agent truly useful in production? It needs a clearly defined job, the ability to use real tools and take action, human approval for important decisions, and a record of what it does. These four traits matter more than any single performance number." width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;That last trait is easy to skip and hard to add later. It's the reason we wrote about agent infrastructure in the first place.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. What Are the Best Enterprise AI Agents to Start With?
&lt;/h2&gt;

&lt;p&gt;The best enterprise AI agents for business to start with have a narrow job, clear data, and a low cost of being wrong. Document review, ticket triage, alert investigation, and drafting for a person to check are common first picks. Money movement and customer commitments come later, with approvals.&lt;/p&gt;

&lt;p&gt;We haven't tested these products, so we won't rank vendors. We can rank jobs by how bad a mistake is, using the examples above.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Starter Job&lt;/th&gt;
&lt;th&gt;Cost of a Mistake&lt;/th&gt;
&lt;th&gt;Example&lt;/th&gt;
&lt;th&gt;Keep a Person On&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Alert and ticket triage&lt;/td&gt;
&lt;td&gt;Low&lt;/td&gt;
&lt;td&gt;Carvana, Zendesk&lt;/td&gt;
&lt;td&gt;The fix&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Drafting and review&lt;/td&gt;
&lt;td&gt;Medium&lt;/td&gt;
&lt;td&gt;Spellbook, EvenUp&lt;/td&gt;
&lt;td&gt;The final sign-off&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Campaign and report setup&lt;/td&gt;
&lt;td&gt;Medium&lt;/td&gt;
&lt;td&gt;Supermetrics&lt;/td&gt;
&lt;td&gt;Going live&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Claims and document intake&lt;/td&gt;
&lt;td&gt;Medium to high&lt;/td&gt;
&lt;td&gt;DXC&lt;/td&gt;
&lt;td&gt;Material decisions&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Payments and payroll&lt;/td&gt;
&lt;td&gt;High&lt;/td&gt;
&lt;td&gt;Qonto&lt;/td&gt;
&lt;td&gt;Every approval&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Start at the top and work down. You learn what your agent gets wrong while it's cheap to learn.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Why Do Some AI Agent Projects Fail?
&lt;/h2&gt;

&lt;p&gt;Reuters reported that Gartner expects over 40 percent of agentic AI projects to be canceled by the end of 2027. Reasons we see in the examples above are broad jobs, no approval points, no record of what the agent did, and no way to measure quality.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fdavpoyw0ad8b7leefzrz.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fdavpoyw0ad8b7leefzrz.jpg" alt="Why do so many AI agent projects struggle to make it into production? Often, the problem isn't the AI itself. It's unclear responsibilities, missing human approval, poor visibility into agent actions, and no way to measure results. Successful agentic systems need clear boundaries, accountability, and measurable outcomes from the start." width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;That forecast is Gartner's, as Reuters reported it. The reasons are our reading of the ten examples, not a study.&lt;/p&gt;

&lt;p&gt;Quality is the one teams forget. If you can't score what the agent did last week, you can't tell if it got better or worse. We cover that in our post on agent evals.&lt;/p&gt;

&lt;h2&gt;
  
  
  7. What AI Agent Use Cases Fit Your Business?
&lt;/h2&gt;

&lt;p&gt;AI agent use cases for business fit best where work is repeatable, text-heavy, and checked by a person at the end. Support, legal review, finance admin, engineering operations, insurance claims, and marketing reporting all show up in the ten examples. Pick the one where your team loses the most hours.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Team&lt;/th&gt;
&lt;th&gt;Use Case&lt;/th&gt;
&lt;th&gt;Example&lt;/th&gt;
&lt;th&gt;Approval to Keep&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Support&lt;/td&gt;
&lt;td&gt;Answer chats, triage tickets&lt;/td&gt;
&lt;td&gt;Klarna, Zendesk&lt;/td&gt;
&lt;td&gt;Escalation to a person&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Legal&lt;/td&gt;
&lt;td&gt;Review and draft documents&lt;/td&gt;
&lt;td&gt;Spellbook, EvenUp&lt;/td&gt;
&lt;td&gt;Attorney sign-off&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Finance&lt;/td&gt;
&lt;td&gt;Prepare payroll and invoices&lt;/td&gt;
&lt;td&gt;Qonto&lt;/td&gt;
&lt;td&gt;Approve before sending&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Engineering&lt;/td&gt;
&lt;td&gt;Investigate alerts, open pull requests&lt;/td&gt;
&lt;td&gt;Carvana, GitHub&lt;/td&gt;
&lt;td&gt;Code review&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Claims&lt;/td&gt;
&lt;td&gt;Classify and read documents&lt;/td&gt;
&lt;td&gt;DXC&lt;/td&gt;
&lt;td&gt;Expert checkpoint&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Marketing&lt;/td&gt;
&lt;td&gt;Report and adjust campaigns&lt;/td&gt;
&lt;td&gt;Supermetrics&lt;/td&gt;
&lt;td&gt;Go live approval&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Before you start, ask three questions. What is the one job? What is the worst thing the agent could do with it? Who approves that step?&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fhhgdel4r376xmm57x11b.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fhhgdel4r376xmm57x11b.jpg" alt="Before putting an AI agent into production, start by asking three simple questions: What specific job should it handle? What is the worst mistake it could make? And who needs to approve the risky actions? Start small, keep a human watching, learn from mistakes, and expand autonomy only when the workflow proves reliable." width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  8. How Does Unmeshed Fit With AI Agents for Business?
&lt;/h2&gt;

&lt;p&gt;Unmeshed runs the steps around your AI agents for business. It lets an agent call tools, pauses for a person to approve, retries failures, and keeps a record of every step. We don't build the agent or the model. We make sure it runs with limits and a log.&lt;/p&gt;

&lt;p&gt;Most of the traits in the last section are plumbing. Approvals, retries, and a record don't come with the model. Somebody has to build them.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgvtw12ro8fjk2sbgbvxk.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgvtw12ro8fjk2sbgbvxk.jpg" alt="AI agents can handle the work, but that doesn't mean they should have unlimited control. Unmeshed adds the steps around your agent — human approval before risky actions, automatic retries, durable execution, and a complete run log. You bring the agent; Unmeshed helps make its execution reliable, controlled, and auditable." width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Agent steps in workflows:&lt;/strong&gt; Build agentic workflows where an agent step sits next to ordinary steps, so the agent has a defined job.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;People where it counts:&lt;/strong&gt; Add approval steps so the workflow stops and waits for a person before something risky happens.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Runs that survive:&lt;/strong&gt; Durable execution means a long run picks up where it stopped after a crash or a wait.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A record of every step:&lt;/strong&gt; You can see what the agent did, in what order, and what came back.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Tools through MCP:&lt;/strong&gt; You can publish workflows as MCP tools, so an agent calls a vetted workflow instead of raw systems. See our MCP page.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Our agent governance page covers the control side in more detail. We come from the team behind Netflix Conductor, and we've kept the focus on running things reliably.&lt;/p&gt;

&lt;p&gt;Now the limits. We aren't a model provider, and we aren't a finished agent product. You bring the agent. You still decide the job, the limits, and who approves.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Let The Agent Work. Keep The Final Say.&lt;/strong&gt;&lt;br&gt;
Add approval steps, retries, and a full run log to any agent, so a person signs off where a mistake would cost you.&lt;br&gt;
&lt;strong&gt;Add My Approval Step&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Conclusion
&lt;/h2&gt;

&lt;p&gt;AI agents for business work best when the job is narrow, and a person stays at the point of consequence. Qonto's customer approves the payroll. EvenUp's attorney signs the draft. Supermetrics starts every campaign paused. None of that comes from a smarter model. It comes from how each company runs the agent.&lt;/p&gt;

&lt;p&gt;That's the part we care about at Unmeshed, back to the bike. Most teams will want training wheels on day one, and that's fine. What matters is that you can take them off slowly. With us, your agent runs as a workflow step. A person approves anything risky, failed calls retry on their own, and every step leaves a record. So when the agent has earned it, you loosen one approval and leave the rest alone.&lt;/p&gt;

&lt;p&gt;Pick one job this week, like ticket triage or contract review. Run it with a person watching, see what the agent gets wrong, and fix that before you widen it. You'll learn more from that one small run than from any list of examples, ours included.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>automation</category>
      <category>architecture</category>
    </item>
  </channel>
</rss>
