From Task to Done: A Step-by-Step Guide to Your First Automated Workflow with Ivy

Are you buried in a mountain of repetitive tasks? From transcribing meeting notes to drafting follow-up emails and generating weekly reports, these essential but time-consuming chores can steal focus from the strategic work that truly drives growth. What if you could delegate these tasks not to a new hire, but to an ever-ready, hyper-efficient AI teammate?

Meet Ivy, your autonomous digital worker. Ivy isn't just another automation tool; she's a proactive AI agent you can delegate complex goals to. You give her an objective, and she handles the rest.

This guide will walk you through setting up your very first automated workflow with Ivy—transforming a manual process into a single, simple command.

First, What is an Autonomous Digital Worker?

Before we dive in, let's clarify what makes an agent like Ivy different. You might be familiar with chatbots that respond to prompts or simple automation scripts that follow rigid rules. An Autonomous Agent like Ivy operates on a higher level.

• Simple Automation: Follows a strict, pre-defined path. If A happens, do B. It can't adapt to unexpected changes.
• Chatbot: Reacts to user input in a conversational format. It's great for answering questions but can't execute multi-step tasks independently.
• Ivy (The Digital Worker): You assign Ivy a high-level goal. She then autonomously plans the strategy, breaks it down into steps, and executes them to achieve the objective. It's the difference between giving someone turn-by-turn driving directions and just telling them, "Get me to the airport."

This is the future of Workflow Automation—treating business logic as code and delegating outcomes, not just instructions.

Step 1: Identify Your First Task for Automation

The perfect first task for Ivy is one that's repetitive, consumes your valuable time, and involves digital information. Think about your daily or weekly grind. What's a process you wish you could just hand off?

Good candidates include:

• Data Analysis: Analyzing sales data and generating a summary report.
• Customer Communications: Processing inbound support emails and drafting initial responses.
• Research: Conducting web research on a specific topic and compiling the findings.
• Meeting Follow-ups: Summarizing a meeting transcript and drafting an email to attendees.

For this guide, let's choose that last one: Summarizing a meeting and drafting a follow-up. It's a common task that's surprisingly time-intensive.

Step 2: Define the Goal and Provide Context

Delegating to your new AI Assistant is like briefing a human team member. You need to provide two key things:

1. The Task: A clear, high-level objective.
2. The Context: All the information and resources needed to complete the task.

For our example, it looks like this:

• Task: "Summarize the attached meeting transcript and draft a follow-up email to the attendees."
• Context: The meeting transcript itself (meeting_notes.txt) and a list of the attendees' email addresses.

By defining the task and context clearly, you give Ivy everything she needs to plan and execute the workflow without further questions.

Step 3: Put Ivy to Work with a Simple API Call

Here’s where the magic happens. You don't need to build a complex, multi-step workflow engine. You just need to tell Ivy what to do using the .do SDK. Integrating Ivy into your application is surprisingly straightforward.

Here's how you'd assign our meeting summary task in TypeScript:

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]']
  }
});

// Get the result from Ivy
console.log(result.emailDraft);

Let's break that down:

1. import { Agent }...: We import the necessary library to communicate with the platform.
2. const ivy = new Agent('ivy'): We initialize our specific Digital Worker, Ivy.
3. await ivy.do({...}): This is the core command. We're delegating the work.
   • The task string tells Ivy the high-level goal.
   • The context object provides the resources she needs—the file path to the transcript and the array of attendees.
4. console.log(result.emailDraft): Once Ivy completes her work, she returns the output. In this case, a fully drafted email ready for your review.

With just a few lines of code, you've triggered a sophisticated process: Ivy will read the file, comprehend the discussion, identify key action items, and compose a professional follow-up email. This is Business-as-Code in action.

Step 4: Review, Iterate, and Scale

The output, result.emailDraft, is now ready for a quick human-in-the-loop review. You can give it a once-over and hit send. The hours spent listening back to a recording and typing notes are condensed into seconds of computation.

Now, think bigger. This script can be integrated into your existing systems. Imagine a workflow where:

1. Your meeting software automatically saves a transcript.
2. This event triggers your script, delegating the summarization task to Ivy.
3. The drafted email appears in your "Drafts" folder, waiting for your final approval.

You’ve just built a powerful, autonomous system that saves you hours every week.

Ready to Delegate?

You've just seen how easy it is to go from a tedious manual task to a fully automated workflow. By leveraging an autonomous AI Teammate like Ivy, you can offload repetitive work and reclaim your time to focus on what matters most.

Stop doing the work. Just delegate it, and get it done.

Ready to build your first automated workflow? Visit ivy.do to learn more and get started with your new autonomous digital worker.