Human-in-the-Loop (HITL) for Your Automated Processes with .do

In the quest for efficiency, full automation is often hailed as the ultimate goal. We build systems to handle tasks from start to finish, removing manual Clicks and human delays. But what happens when the process requires nuance, judgment, or a level of accountability that a machine can't provide? Full automation isn't always the answer. Sometimes, the most powerful workflow is one that knows when to pause and ask for help.

This is the principle behind Human-in-the-Loop (HITL) automation. It's about creating a partnership between machine efficiency and human intelligence. With the .do Agentic Workflow Platform and our developer-friendly SDKs, you can build sophisticated processes that seamlessly integrate these essential human checkpoints.

What is Human-in-the-Loop (HITL)?

Human-in-the-Loop is a model where an automated system intentionally pauses a process to request input, approval, or validation from a person before continuing. Instead of being a roadblock, this intervention becomes a crucial, designed step in the workflow.

Think about it:

• Expense reports: Automatically approve any expense under $50, but flag anything over $1000 for manager review.
• Content moderation: An AI agent automatically filters spam and hate speech but flags borderline content for a human moderator to make the final call.
• Customer onboarding: An automated process provisions a new account but pauses to wait for a human to verify a user's identity documents.

In each case, automation handles the repetitive, high-volume work, freeing up human experts to focus on the edge cases, a critical decision, and a high-stakes task that requires their unique judgment.

Implementing HITL with the .do SDK: A Practical Guide

The .do platform is designed for exactly this kind of flexible, real-world logic. Our agentic workflows aren't just rigid, sequential scripts; they are dynamic processes that can change state, wait for external events, and resume based on new inputs. The .do SDK is your bridge to implementing this in your own applications.

Here’s how a typical HITL workflow looks when built with .do:

1. Trigger the Workflow: Your application uses the .do SDK to start a workflow, just like any other automated process. This could be triggered by an API call, a new database entry, or a user action in your app.
2. Run Until Pause: The .do agent executes the initial automated steps—gathering data, calling other APIs, performing calculations.
3. Pause for Human Input: At a predefined step (e.g., await_manager_approval), the workflow's state changes to PAUSED. It generates a unique token or ID for this specific task and waits.
4. Notify the Human: Your application, notified of the paused state via a webhook from .do, sends an alert to the designated person. This could be an email, a Slack message, or a task appearing in their dashboard within your application.
5. Human Makes a Decision: The user reviews the data and submits their decision (e.g., 'Approve', 'Reject', 'Request More Info') through a simple interface that you build.
6. Resume the Workflow: This is where the magic happens. Your backend receives the decision and uses the .do SDK to send a signal back to the paused workflow, providing the human's input as part of the payload. The workflow then resumes from where it left off, using the new data to inform its next steps.

Code Example: Resuming a Workflow with Human Approval

Let's imagine you've built a simple UI for a manager to approve a large customer refund. When they click "Approve," your backend receives the request and executes a function like this using our TypeScript SDK:

import { Do } from '@do-platform/sdk';

const doClient = new Do({
  apiKey: process.env.DO_API_KEY,
});

// This function would be called by your API endpoint
// after a manager approves a request from your UI.
async function resumeRefundWorkflow(runId: string, managerDecision: 'approved' | 'rejected', comment: string) {
  try {
    const result = await doClient.workflows.resume({
      runId: runId, // The ID of the paused workflow instance
      input: {
        decision: managerDecision,
        managerNotes: comment,
      },
    });
    console.log(`Workflow ${runId} resumed successfully.`);
    return result;
  } catch (error) {
    console.error(`Failed to resume workflow ${runId}:`, error);
  }
}

This elegant piece of code connects your human-driven decision directly back into the automated process, blending the best of both worlds.

Why Build Your HITL System on .do?

• Clarity and Simplicity: Define complex business logic, including pauses and human handoffs, as simple code. The .do SDK provides a clear and straightforward interface for managing this.
• Full Audit Trail: Every step, including the pause, the human input, and the resumption, is logged within the .do platform. This provides an invaluable, auditable history for compliance and debugging.
• Scalability: Let automation handle 99% of cases while seamlessly routing the critical 1% to your team. Your team can focus on value, not volume.
• Decoupled Logic: Your core application doesn’t need to contain messy state management for long-running, pausable tasks. It simply triggers and resumes workflows, leaving the hard parts to the robust .do agentic platform.

Get Started with Smarter Automation

Stop thinking about automation as an all-or-nothing proposition. The most resilient and intelligent systems are those that know their own limits. By integrating Human-in-the-Loop checkpoints, you build safer, more reliable, and vastly more powerful applications.

Ready to build your first HITL process?

1. Get Your API Key: Sign up for a .do account and generate an API key from your dashboard.
2. Explore the Docs: Dive into our developer documentation to learn more about our SDKs for TypeScript, Python, and more.
3. Build Your Workflow: Start modeling a process that could benefit from a human touch.

With .do, you have the developer tools to build automation that works for your business, not the other way around.