The Developer's Guide to Commanding Ivy: Mastering the .do SDK

In the world of software development, your most valuable asset is your focus. Yet, how much of your day is spent on tasks that aren't coding? Generating reports, summarizing meeting notes, triaging support tickets, wrangling data—these repetitive but necessary chores fragment your attention and slow down your real work.

What if you could delegate those tasks just as you would to a junior team member?

Meet Ivy, your autonomous digital worker. Powered by the .do platform, Ivy isn't just another API or automation tool. She is a proactive AI teammate you can command directly from your code. This guide will show you how to master the .do SDK and turn complex business processes into a single line of code.

Beyond the Chatbot: Why an Autonomous Agent Changes Everything

You've worked with APIs and you've probably seen chatbots. Ivy is a fundamental shift from both.

• A chatbot is reactive. It waits for a specific prompt and provides a constrained, immediate response. Think of it as a calculator: you provide 2+2, it returns 4.
• An autonomous agent like Ivy is proactive. You give her a high-level goal, and she independently plans, strategizes, and executes the multi-step process required to achieve it. Think of her as an analyst: you say, "Analyze our weekly sales data and report on key trends," and she figures out how to open the file, perform the analysis, structure the findings, and generate the report.

This is the principle of Business-as-Code. By using the .do SDK, you are programmatically directing a digital worker to execute complex business logic, allowing you to version, scale, and automate workflows that were previously manual.

Getting Started: Your First Command with the .do SDK

Ready to delegate? Let's get Ivy working for you in three simple steps.

Step 1: Install the SDK

First, add the .do SDK to your project using your preferred package manager.

npm install @do/sdk

Step 2: Initialize the Agent

In your application file, import the Agent class and initialize Ivy. It's as simple as creating a new object.

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

// Initialize the Ivy agent
const ivy = new Agent('ivy');

Step 3: Assign Your First Task

Now for the magic. Use the ivy.do() method to assign a task. This method takes a high-level objective described in natural language and a context object containing any necessary data or resources.

Let's use the example from the ivy.do homepage. We'll ask Ivy to summarize a meeting transcript and draft a follow-up email.

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

// Initialize the Ivy agent
const ivy = new Agent('ivy');

// Assign a task to Ivy
const { result } = await ivy.do({
  task: 'Summarize the attached meeting transcript and draft a follow-up email to the attendees.',
  context: {
    transcript: 'file://./meeting_notes.txt',
    attendees: ['[email protected]', '[email protected]']
  }
});

// Ivy returns a structured result
console.log(result.emailDraft);

Let's break that down:

• task: This is your goal, described in plain English. The more descriptive you are, the better Ivy can perform.
• context: This object provides Ivy with the resources she needs. Here, we've provided a local file path for the transcript and an array of attendee emails. You can pass file paths, URLs, raw text, or structured data.
• result: Ivy doesn't just complete the task; she returns a structured object with the deliverables. In this case, we can directly access the emailDraft she created.

That's it. You've just delegated a multi-step cognitive task to an autonomous AI agent.

Unlocking Powerful Workflows: Practical Use Cases

The true power of Ivy is unlocked when you integrate her into your existing applications to automate entire workflows.

Use Case 1: Automated Business Intelligence Reporting

Imagine a cron job that runs every Monday morning. Instead of a complex script for data processing and visualization, you simply command Ivy.

// report_generator.ts
import { Agent } from '@do/sdk';
const ivy = new Agent('ivy');

async function generateWeeklyReport() {
  console.log('Asking Ivy to generate the weekly sales report...');
  const { result } = await ivy.do({
    task: 'Analyze the attached sales data CSV. Identify the top 5 performing products, calculate week-over-week revenue growth, and generate a 1-page PDF summary. Email the final PDF to the sales leadership team.',
    context: {
      salesData: 'file://./data/latest_sales.csv',
      salesLeadership: ['[email protected]', '[email protected]']
    }
  });
  console.log(`Report generation complete. Task ID: ${result.taskId}`);
}

generateWeeklyReport();

Use Case 2: Intelligent Customer Support Triage

Integrate Ivy with your helpdesk webhook. When a new high-priority ticket arrives, Ivy can handle the initial analysis and communication.

// triggered on new support ticket via API
import { Agent } from '@do/sdk';
const ivy = new Agent('ivy');

export async function handleNewTicket(ticket) {
  const { result } = await ivy.do({
    task: 'Analyze this support ticket. If it mentions "critical outage" or "system down", immediately escalate it to the on-call engineer and draft a high-priority holding email to the customer acknowledging the urgency. Otherwise, categorize its topic and draft a standard first-reply.',
    context: {
      ticketDetails: ticket,
      onCallEngineer: '[email protected]'
    }
  });

  if (result.escalated) {
    // Logic to page the on-call engineer using result.escalationMessage
  } else {
    // Logic to post result.emailDraft back to the helpdesk
  }
}

Welcome to the Future of Work

By integrating Ivy into your stack, you're not just adding a tool—you're adding a teammate. The .do SDK is your direct line to an autonomous digital worker ready to take on the repetitive, time-consuming tasks that stand between you and your next great feature.

Stop wrestling with tedious chores. Delegate to Ivy, and get back to building what matters most.

Ready to build your AI-powered team? Visit ivy.do to get your API key and start delegating today!