How to Integrate an Autonomous Worker into Your App with the .do SDK

In today's fast-paced digital landscape, developers are constantly tasked with building more intelligent and capable applications. While traditional automation is great for repetitive, rule-based tasks, what about the complex, multi-step objectives that usually require human intervention? This is where the next evolution in automation comes in: the autonomous digital worker.

Empower your applications with agentic intelligence. Meet Ivy, your pre-built autonomous digital worker on the .do platform. Ivy is designed to understand and execute complex business goals, turning cumbersome operations into simple, scalable, on-demand services.

This tutorial will show you just how easy it is to integrate Ivy into your existing stack and start delegating complex tasks in just a few lines of code using the .do SDK.

What is an Autonomous Worker (and Why is it a Game-Changer)?

Before we dive into the code, let's clarify what makes an autonomous worker like Ivy so powerful.

Unlike a simple script or a rigid automation bot, an autonomous worker operates on an "agentic" model. This means it can:

• Reason: Understand a high-level objective described in natural language.
• Plan: Break down the objective into a series of logical steps.
• Utilize Tools: Autonomously use different tools (like web search, data analysis libraries, or file I/O) to execute its plan.
• Adapt: Adjust its approach if it hits a roadblock, much like a human would.

Think of it as the difference between giving a team member a rigid, 100-step checklist versus just telling them, "Please research our top three competitors and summarize their marketing strategies." An autonomous worker handles the latter, giving you a powerful new capability to embed directly into your software.

Step-by-Step Guide: Integrating Ivy with the .do SDK

Let's get hands-on. We'll walk through adding Ivy to a standard Node.js/TypeScript project.

Prerequisites

• Node.js and npm (or yarn) installed.
• An account on the .do platform and your API key.

Step 1: Install the .do SDK

First, add the official SDK to your project's dependencies. Open your terminal and run:

npm install @do-inc/sdk

This package is the gateway to the entire .do platform, including the Ivy agent.

Step 2: Initialize the Ivy Agent

Now, in your application code, you can import the Do client and initialize a connection to Ivy. It's as simple as referencing the agent by its name.

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

// Configure the client with your API key
// (It's best practice to use environment variables for this)
// Do.config({ apiKey: 'YOUR_API_KEY' });

// Initialize a handle for the Ivy agent
const ivy = Do.agent('ivy');

console.log('Successfully connected to Ivy!');

With just two lines of code, your application now has a direct line to a powerful AI agent.

Step 3: Delegate Your First Complex Task

This is where the magic happens. To give Ivy a task, you use the asynchronous run method. You provide an objective-driven prompt and tell Ivy how you want the output delivered.

Let's use the full example from the ivy.do website:

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

// Initialize the client for the Ivy agent
const ivy = Do.agent('ivy');

// Assign a complex research task to Ivy
const taskResult = await ivy.run({
  task: "Analyze Q1 2024 customer feedback and generate a sentiment analysis report.",
  output: {
    format: "pdf",
    path: "./reports/sentiment-analysis-q1.pdf"
  }
});

console.log(`Task complete. Report saved to ${taskResult.output.path}.`);

Let's break down the ivy.run() call:

• await: Ivy's tasks are complex and can take time. The run method is asynchronous, allowing your application to continue running while Ivy works in the background.
• task: This is the natural language instruction. Notice how it's a high-level goal, not a series of specific commands. Ivy will figure out the necessary steps: finding the data, choosing a sentiment analysis model, structuring the report, and generating the final document.
• output: Here, you specify the desired format and location for the deliverable. Ivy will handle the creation and saving of the file.

When the await resolves, taskResult will contain information about the completed job, including the path to your newly generated report. That's it! You've successfully delegated a complex business process to an autonomous worker through a simple API call.

What's Next? Unlocking Agentic Workflows

The example above is just the beginning. You can integrate Ivy into your workflows to:

• Automate Market Research: await ivy.run({ task: "Find and summarize the latest trends in the renewable energy sector for a weekly investor briefing." });
• Enhance Data Pipelines: Trigger Ivy to analyze new datasets as they arrive in your database.
• Build "Services-as-Software": Create an internal endpoint in your company's app that allows any department to request complex reports on-demand, powered by Ivy.
• Summarize Content: await ivy.run({ task: "Summarize the key points from the attached transcript and list all action items." });

By treating complex operations as programmable, on-demand services, you can build smarter, more powerful applications with unprecedented speed.

Frequently Asked Questions (FAQs)

Q: What is Ivy?
A: Ivy is a pre-built autonomous digital worker on the .do platform. It's designed to understand and execute complex business tasks assigned via API, transforming your operational workflows into programmable, on-demand services.

Q: What kinds of tasks can Ivy perform?
A: Ivy can handle a wide array of business processes, including data analysis, market research, report generation, content summarization, and process automation. Any objective-driven task can be delegated to Ivy.

Q: How does Ivy differ from a standard automation tool?
A: Unlike simple scripts or bots that follow rigid rules, Ivy is an agentic worker. It can reason, plan multi-step actions, and utilize various tools to achieve a given objective, adapting its approach to complete complex tasks autonomously.

Q: How do I integrate Ivy into my business?
A: You can integrate Ivy seamlessly into your existing applications and workflows using the .do platform's simple APIs and SDKs. Treat Ivy as a service that you can call to execute tasks, just like any other modern software API.

Ready to give your application a digital teammate? Visit ivy.do to learn more and get started on the .do platform today.