> ## Documentation Index
> Fetch the complete documentation index at: https://academy.pathfindr.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Designing Your AI Agent

> Map your current workflows, identify where agents fit, and write agent job descriptions using the what/when/how framework.

export const Quiz = ({question, options, correctIndex, explanation}) => {
  const [selected, setSelected] = useState(null);
  const [showResult, setShowResult] = useState(false);
  const handleSelect = index => {
    if (showResult) return;
    setSelected(index);
    setShowResult(true);
  };
  const isCorrect = selected === correctIndex;
  return <div className="my-8 p-6 rounded-2xl border border-zinc-200 dark:border-zinc-700 bg-gradient-to-br from-zinc-50 to-white dark:from-zinc-900 dark:to-zinc-800 shadow-sm">
      <div className="flex items-center gap-3 mb-4">
        <div className="flex items-center justify-center w-10 h-10 rounded-xl bg-blue-100 dark:bg-blue-900/40">
          <span className="text-xl">📝</span>
        </div>
        <div className="flex flex-col">
          <p className="font-semibold text-zinc-800 dark:text-zinc-100 m-0">Knowledge Check</p>
          <p className="text-xs text-zinc-500 dark:text-zinc-400 mt-0.5 m-0">Select the best answer</p>
      </div>
      </div>
      
      <p className="text-zinc-700 dark:text-zinc-200 font-medium mb-5 text-lg leading-relaxed">{question}</p>
      
      <div className="space-y-3">
        {options.map((option, index) => {
    const isSelected = selected === index;
    const isCorrectOption = index === correctIndex;
    let optionStyles = "border-zinc-200 dark:border-zinc-600 hover:border-blue-400 hover:bg-blue-50 dark:hover:bg-blue-900/20";
    if (showResult) {
      if (isCorrectOption) {
        optionStyles = "border-green-500 bg-green-50 dark:bg-green-900/30";
      } else if (isSelected && !isCorrectOption) {
        optionStyles = "border-red-500 bg-red-50 dark:bg-red-900/30";
      } else {
        optionStyles = "border-zinc-200 dark:border-zinc-700 opacity-60";
      }
    }
    return <button key={index} onClick={() => handleSelect(index)} disabled={showResult} className={`w-full text-left p-4 rounded-xl border-2 transition-all duration-200 ${optionStyles} ${!showResult && 'cursor-pointer'} ${showResult && 'cursor-default'}`}>
              <div className="flex items-start gap-3">
                <div className={`flex-shrink-0 w-6 h-6 rounded-full border-2 flex items-center justify-center text-xs font-bold ${showResult && isCorrectOption ? 'border-green-500 bg-green-500 text-white' : showResult && isSelected && !isCorrectOption ? 'border-red-500 bg-red-500 text-white' : 'border-zinc-300 dark:border-zinc-500 text-zinc-500 dark:text-zinc-400'}`}>
                  {showResult && isCorrectOption ? '✓' : showResult && isSelected ? '✗' : String.fromCharCode(65 + index)}
                </div>
                <span className="text-sm text-zinc-700 dark:text-zinc-200 leading-relaxed">{option}</span>
              </div>
            </button>;
  })}
      </div>
      
      {showResult && <div className={`mt-5 p-4 rounded-xl ${isCorrect ? 'bg-green-100 dark:bg-green-900/40 border border-green-200 dark:border-green-800' : 'bg-amber-100 dark:bg-amber-900/40 border border-amber-200 dark:border-amber-800'}`}>
          <div className="flex items-start gap-3">
            <span className="text-xl">{isCorrect ? '🎉' : '💡'}</span>
            <div className="flex flex-col">
              <p className={`text-sm font-semibold m-0 mb-1 ${isCorrect ? 'text-green-800 dark:text-green-200' : 'text-amber-800 dark:text-amber-200'}`}>
                {isCorrect ? 'Correct!' : 'Not quite right'}
              </p>
              <p className="text-sm text-zinc-600 dark:text-zinc-300 m-0 leading-relaxed">{explanation}</p>
          </div>
          </div>
        </div>}
    </div>;
};

<img src="https://mintcdn.com/pathfindr/I3XbhzOlK6BeuXVO/images/clearFramework.webp?fit=max&auto=format&n=I3XbhzOlK6BeuXVO&q=85&s=984f8d2894e9cba45a3f5a20c5f3d11f" alt="designing your AI agent framework" noZoom={true} width="1284" height="636" data-path="images/clearFramework.webp" />

## What you will learn

Building an agent without understanding the work it needs to do is like hiring someone without writing a job description. You might get lucky. More likely, you will waste time fixing something that was never set up properly.

This section gives you the method for designing agents that actually solve the right problem.

<CardGroup cols={4}>
  <Card title="Map the work" icon="square-1">
    Break down a current process into steps before deciding what to automate
  </Card>

  <Card title="What / When / How" icon="square-2">
    Use a simple framework to define agent responsibilities clearly
  </Card>

  <Card title="Write a job description" icon="square-3">
    Create a structured brief that translates directly into an agent build
  </Card>

  <Card title="Spot the blockers" icon="square-4">
    Identify data access, integration, and permission issues before you start building
  </Card>
</CardGroup>

***

## Start with the work, not the tool

The temptation is to jump straight into a platform and start building. That is the equivalent of hiring someone on day one without ever defining the role.

The more valuable step is to slow down and look at the work itself. What are you doing today? Where does your time go? What is manual, repetitive, or frustrating?

<Tip>
  This is not new thinking. It is the same process mapping you would do if you were restructuring a team or onboarding a new hire. The difference is that the new hire is an AI agent, and it needs even more clarity than a human, because it will do exactly what you tell it, no more and no less.
</Tip>

### A real example: Pathfindr's content pipeline

Internally at Pathfindr, the team faced this exact challenge. One team member was responsible for keeping the Academy Portal content up to date: updating blog posts when AI tools released new features, writing in the Pathfindr voice, structuring content into the right format, and publishing it.

The manual process looked like this:

<Steps>
  <Step title="Check existing content">
    Browse what is already published to see what needs updating
  </Step>

  <Step title="Research updates">
    Search official documentation and release notes for the latest changes across ChatGPT, Claude, Copilot, and Gemini
  </Step>

  <Step title="Draft new content">
    Use AI to write a first version, applying the Pathfindr tone and structure
  </Step>

  <Step title="Review and refine">
    Add dynamic components, check formatting, and do a human review
  </Step>

  <Step title="Publish">
    Push the updated content live on the platform
  </Step>
</Steps>

Once mapped, the team could see which steps were candidates for automation. The research, drafting, and publishing steps became four sub-agents: a news researcher, a blog writer, an image manager, and a repository manager.

The human review step stayed with the team member, because that is where their judgement adds the most value.

<Tip title="The principle at work here">
  Map first. Automate second. The agents you build will only be as good as your understanding of the work they need to do.
</Tip>

<Accordion title="Test your understanding">
  <Quiz
    question="Your team currently spends 3 hours every Friday compiling a weekly project status report from emails, Slack, and a project management tool. You want to automate this. What is the most important first step?"
    options={[
  "Open Relay and start building an agent immediately",
  "Map out the current process step by step: what data comes from where, what the report structure looks like, and who receives it",
  "Ask ChatGPT to write you a weekly report",
  "Set up integrations with all your tools first"
]}
    correctIndex={1}
    explanation="Mapping the current process is always the first step. You need to understand what the agent will actually do before you build it. Jumping straight into a tool without understanding the workflow leads to agents that automate the wrong thing or miss critical steps."
  />
</Accordion>

***

## The What / When / How framework

Once you have mapped the work, you need a way to translate each task into something an agent can execute. The framework is simple: What should the agent do? When should it trigger? How should it execute?

<CardGroup cols={4}>
  <Card title="What" icon="clipboard-question">
    Define the task clearly. What is the agent responsible for delivering? What does the output look like?
  </Card>

  <Card title="When" icon="clock">
    Define the trigger. Is it time-based (every Monday at 9am)? Event-based (when a file is added to a folder)? On demand?
  </Card>

  <Card title="How" icon="gears">
    Define the execution. What tools does it need? What steps does it follow? Where does the output go?
  </Card>

  <Card title="Who reviews" icon="user-check">
    Define the human checkpoint. Who reviews the output before it goes live? What level of oversight does this task need?
  </Card>
</CardGroup>

### Example: Meeting preparation agent

Here is how the framework applies to a common leadership pain point: arriving at meetings unprepared.

|             | Detail                                                                                                                                                                            |
| ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| <b>What</b> | Research attendees, pull related documents and recent emails, and send a briefing summary                                                                                         |
| <b>When</b> | 24 hours before each meeting in my calendar                                                                                                                                       |
| <b>How</b>  | Check calendar for upcoming meetings. Look up each attendee on LinkedIn and in email history. Search Drive for related documents. Compile a briefing and send it to me via email. |

Notice that each component is specific. Not "prepare me for meetings", but exactly what to research, when to trigger, and how to deliver the output.

<Accordion title="Test your understanding">
  <Quiz
    question="You are writing an agent job description for a competitive analysis agent. Which of these is a well-written 'When' trigger?"
    options={[
  "When I need competitive insights",
  "Every Monday at 8am AEST",
  "Regularly",
  "When competitors do something interesting"
]}
    correctIndex={1}
    explanation="A good trigger is specific and unambiguous. 'Every Monday at 8am' is something an agent can act on. 'When I need insights' or 'regularly' are too vague for an agent to interpret. They require human judgement to decide when to fire, which defeats the purpose of automation."
  />
</Accordion>

***

## Writing the agent job description

When you put this together, you get something that looks like a job description for a new team member. This is deliberate. The clearer the brief, the better the agent performs.

A strong agent job description includes:

<CardGroup cols={2}>
  <Card title="Job title and purpose" icon="id-badge">
    One sentence on what this agent does and why it exists.
  </Card>

  <Card title="Responsibilities" icon="list-check">
    The specific tasks it performs, each written in the what/when/how format. An agent might have one responsibility or five, just like a human role.
  </Card>

  <Card title="Data and access requirements" icon="database">
    What tools, platforms, and data sources does the agent need to connect to? Gmail, Google Drive, LinkedIn, Slack, a CRM, a project management tool?
  </Card>

  <Card title="Potential blockers" icon="triangle-exclamation">
    What could prevent this from working? IT permissions, tool integrations that do not exist yet, data that lives in a system the agent cannot reach?
  </Card>
</CardGroup>

<Info title="One responsibility or many?">
  A single agent can have multiple skills or responsibilities. Your personal assistant agent might triage emails, send meeting briefings, and track project statuses: three separate responsibilities under one role. Each one follows the what/when/how framework independently.
</Info>

***

## The three-step evolution

The founder of Relay frames the agent-building journey in three stages. This is a useful way to think about where to start and where you are headed.

<AccordionGroup>
  <Accordion title="Step 1: Delegate the mundane" icon="broom">
    Start with tasks you are already doing that are boring, repetitive, or time-consuming. Filing documents into the right folder. Renaming files to match a convention. Sending RSVP reminders before meetings. These are low-risk, high-frequency tasks where agents deliver immediate value and you build trust in the system.
  </Accordion>

  <Accordion title="Step 2: Amplify what you could do" icon="magnifying-glass-plus">
    Move to tasks you are capable of doing but never have enough time for. Reading every competitor's LinkedIn posts. Watching every relevant YouTube video in your industry. Scanning every blog post in your niche. You have the skill to do this analysis, you just do not have the hours. Agents give you that capacity back.
  </Accordion>

  <Accordion title="Step 3: Access expertise you do not have" icon="graduation-cap">
    Finally, use agents for work that requires knowledge you do not personally hold. Financial modelling if you are not an accountant. Legal document review if you are not a lawyer. Technical analysis if you are not an engineer. The agent brings the subject matter expertise. You bring the business judgement about what to do with the results.
  </Accordion>
</AccordionGroup>

Most people should start at Step 1. Get comfortable. Build trust. Then expand.

***

## Quick checkpoint

You are done with this section when you can:

<CardGroup cols={4}>
  <Card title="Map a process" icon="circle-check">
    Break down one of your current workflows into clear, sequential steps
  </Card>

  <Card title="Apply What / When / How" icon="circle-check">
    Write at least one agent responsibility using the framework
  </Card>

  <Card title="Write the brief" icon="circle-check">
    Produce a job description for an agent that includes purpose, responsibilities, access needs, and blockers
  </Card>

  <Card title="Start at Step 1" icon="circle-check">
    Identify a mundane, repeatable task in your work that is a strong candidate for your first agent
  </Card>
</CardGroup>

<div className="mt-8" />

<Card title="Next: Building and Testing in Relay" icon="arrow-right" href="/leadership-cohort/week-4-build-your-own-ai-agents/building-in-relay">
  Learn how to turn your agent design into a working workflow in Relay
</Card>