Adsurdly · AI training
6 workshop pages March 2026
Working with agents Field notes / edition 03

Working With Agents

Operating patterns for directing agents well: plan, context, tools, stages, and verification.

Reading map

Working With Agents

Once you understand the basic concepts, the next skill is learning how to direct an agent well.

This is mostly about operating patterns, not tools.

Good results usually come from five things:

  • a clear goal
  • the right context
  • the right tools
  • checkpoints during the work
  • a clear way to verify the result

1. Ask for a plan first

Before you ask an agent to do the work, ask it to plan the work.

Have it outline:

  • the goal
  • the steps
  • assumptions
  • risks
  • what it needs from you

This helps you catch bad assumptions early and gives the agent a better structure before it starts.

Example

Instead of:

  • Build this landing page

Try:

  • First make a plan for this landing page. List the sections, content needed, dependencies, and open questions before you implement it.

2. Separate structure from output

A strong pattern is to create the structure first, then produce the final output.

Examples:

  • make an email template before writing a full sequence
  • make a report format before generating a client report
  • make an outline before drafting an article

This gives you a reusable system, not just a one-off result.

Example

Instead of:

  • Write 10 outreach emails for this niche

Try:

  • First create a reusable outreach template for this niche. After we refine it, use it to generate 10 final emails.

3. Load the right context first

If the task depends on known standards, patterns, or source material, bring that into context before the agent starts.

Examples:

  • best practices
  • examples to model
  • source documents
  • brand rules
  • reporting formats

This usually produces better work than asking the agent to guess from general knowledge.

Example

Instead of:

  • Write an SEO page for this service

Try:

  • First research current best practices for a local service page like this. Summarize the important patterns. Then use those patterns to draft the page.

A practical way to store reusable context

If you use agents often, keep repeated instructions in an AGENTS.md file in the project or working folder.

Use it for things like:

  • project rules
  • writing or formatting standards
  • tool limitations
  • review steps
  • what done means

This gives the agent the same working instructions each time instead of making you repeat them in every prompt.

Example

An AGENTS.md file might say things like:

  • use this report format
  • do not change live client data directly
  • ask for approval before sending outreach
  • run these checks before finishing

AGENTS.md does not replace judgment. It helps the agent start with the right context and stay consistent.

4. Give the agent real tools

Agents can only do the work if they have a real way to do the work.

If a task depends on a browser, API, CRM, database, or internal system, give the agent access through a tool, script, export, or clear workflow.

Do not ask for outcomes that depend on systems the agent cannot reach.

Example

Instead of:

  • Pull all active ads from our Facebook account

Try:

  • First build or connect a simple tool that can list active ads from this account. Confirm it works. Then use it to pull the ads and format the results.

5. Work in stages

Do not treat the agent like a one-shot answer machine.

A better pattern is:

  1. understand the task
  2. make a plan
  3. gather context
  4. get the needed tools
  5. draft
  6. review
  7. refine

Review after major steps like the plan, research, template, or first draft. This gives you better control and makes it easier to redirect the work early.

6. Verify the result

Ask the agent not only to do the work, but to check the work.

Examples:

  • open the page in a browser and confirm it matches the spec
  • run tests to confirm the code still works
  • run linters and formatters
  • compare the output against a checklist or source material

Example

Instead of:

  • Update this page

Try:

  • Update this page, then verify that the headline, CTA, and mobile layout match the spec. If anything is off, fix it and verify again.

7. Define what done means

Do not make the agent guess what complete means.

Give it:

  • examples to model
  • a checklist to follow
  • a clear definition of done

A good definition of done can include:

  • what the final output should contain
  • what files or deliverables should exist
  • what must be checked before finishing
  • what would make the work incomplete

Example

Instead of:

  • Make this report client-ready

Try:

  • Use this sample report as the model. Include wins, risks, next steps, and screenshots. This is done when every metric is labeled, every claim is sourced, and the final report matches the sample structure.

8. Reset the context when needed

Agents work from the context they are given.

If the task changes, the conversation gets noisy, or the agent is drifting, restate the task clearly instead of piling on more corrections.

That can mean:

  • rewriting the request
  • starting a fresh thread
  • removing outdated assumptions
  • restating the goal based on what you learned

Bad context leads to bad output.

A simple rule to remember

A useful pattern for many tasks is:

  1. plan
  2. load context
  3. give tools
  4. define done
  5. create structure
  6. produce output
  7. verify
  8. review
  9. refine

What to do next

After this, review Getting started to choose a harness, tools, and a simple workflow to test.