Early draft Who’s in the Loop? · A Meaxy field guide

The prompt is only the beginning.

A practical guide to AI agent workflows.Chapter one · Approximately 10 minutes

Meaxy, the round white mascot, mid-thought.

This is the opening draft of a book in development. The working title, chapter structure, and examples may evolve. The support team in this chapter is an illustrative scenario.

Imagine a small software team building an assistant for its support inbox. A customer writes: “The weekly export is missing three projects. Can you fix it before our review?” The team gives the request to an AI and asks for a helpful reply.

Seconds later, the answer appears. It is warm, concise, and impressively calm. It apologizes for the inconvenience, says the issue has been identified, and promises that a corrected export will arrive shortly. Everyone enjoys this for approximately four seconds.

Then someone asks a small question: did anything actually happen?

No export was inspected. No project list was compared. No repair was attempted. The AI produced a convincing message about work that had not occurred. This is a fictional example, but it gives us a useful starting point: an answer and an outcome are different things to build.

An agentic workflow is the system we put around the model to help it make progress toward an outcome. That system includes the information it receives, the tools it can use, the decisions it can make, the state it keeps, and the checks that determine what happens next. The prompt matters. So does everything the prompt cannot enforce by itself.

From meat proxy to workflow designer

The phrase “meat proxy” gives this problem a memorable name. On meatproxy.me, it describes a person who relays questions to AI and passes the answers back without adding judgment. It is a joke about the role the person is playing, not a useful measure of anyone’s intelligence.

Someone sends you a question. You copy it into a chat. The chat produces an answer. You copy that answer back. If you never inspect the assumptions, verify the consequential details, or explain the decision, you have mostly become part of the transport layer. The typing happened; the responsibility is still waiting for an owner.

The answer is not to perform extra manual work just to prove that you participated. There are good reasons to delegate an entire routine task. The useful question is whether you shaped the task, gave it appropriate boundaries, and established how its result would be checked. A carefully designed automated workflow can carry more of your judgment than a dozen unexamined approvals.

This is the move from meat proxy to workflow designer. In our support example, the designer defines which records the system may inspect, what a useful draft must contain, and which uncertainty requires another person. A reviewer evaluates a specific draft against those expectations. The model helps with the work; the process gives the work a standard.

Adding more agents does not automatically make that standard better. A relay can become a committee of relays. Before you introduce a planner, a researcher, and a critic, ask what each one can observe, decide, and verify that the existing process cannot. If nobody has an answer, the new organization chart may be the most complete artifact the system produces.

A useful definition before we build

People use “agent” for several kinds of software. In this book, a workflow means a process whose main steps are chosen by its designer. An agent is a component that can choose its next step using a model, within the boundaries of the surrounding software. One product can contain both. Anthropic makes a similar distinction between predefined workflows and model-directed agents.

For example, a fixed support workflow might retrieve a customer’s case, retrieve the relevant help article, draft a response, and present it for review. A model-directed agent might inspect the case and choose whether to look up an export, compare project permissions, or ask for missing information. The meaningful difference is who chooses the next step.

The word agentic describes how much decision-making the model participates in. It does not tell you whether the process is useful, reliable, or appropriate for the job. Those questions require evidence from the work you actually want done.

Give the job a finish line

Return to the missing export. “Help this customer” sounds reasonable until you try to check whether it happened. A polite apology might qualify. So might a draft, a repaired export, or a refund. Each outcome needs different information and authority.

For a first version, choose a smaller finish line: prepare a support draft that accurately explains what is known about the missing projects, includes the evidence a reviewer needs, and makes no unsupported claim that a repair has happened. The workflow may inspect approved records and create a draft. It may not send the message or change project permissions.

This is a design choice for our example, not a universal rule that every message needs approval. A mature system might automatically send a narrow category of verified responses. That is a separate capability to design and evaluate. Our first version should be small enough that we can understand its behavior.

A useful job description explains what done means, what may change, and what evidence will prove it.

Write the brief before selecting a framework. It should name the outcome, the inputs, the available actions, the limits, and the person or process responsible for unresolved cases. If the team cannot agree on these in ordinary language, software will not settle the disagreement.

Follow one request through the system

The customer’s message enters the workflow with a case identifier and an authenticated account identifier. The application looks up the case using permissions enforced by the service. The model does not get to invent which customer account it belongs to.

A read-only tool returns the export identifier, its recorded generation time, the projects included, and the relevant access information. The model can compare the complaint with those records. It might discover that three projects were added after the export ran. It might find a mismatch it cannot explain. It might discover that the export record is unavailable.

Each of those observations should lead to a different result. If the timing explains the difference, the draft can describe that finding and propose a next step. If the evidence is incomplete, the draft should say what remains unknown. If the tool fails, the workflow needs a recovery path; it cannot treat an empty response as proof that no projects exist.

The model prepares a response and a compact evidence summary. The application checks the fields it can validate directly: the case identifier matches, source references exist, required output fields are present, and no action outside the allowed tool set was executed. A reviewer then assesses the claims and the proposed next step.

Notice what the check does and does not prove. A well-formed response can still contain an unsupported conclusion. A source reference can exist while failing to support the sentence next to it. Structural validation is one layer; evaluating the meaning is another. We need both when the task calls for both.

Treat a tool result as an observation

A tool is a bridge between generated instructions and a system that can return information or change something. The bridge deserves careful design. “Search everything” is a very different capability from “read the export record for this authorized case.” Clear inputs and narrow responsibilities make the tool easier to reason about.

Tools should also explain failure. The application needs to distinguish “record not found” from “you do not have access” and “the service did not respond.” These states suggest different next steps. A blank string leaves both the agent and its operator guessing.

For actions that change state, a timeout deserves special attention. A request might succeed even if its response never reaches the caller. If creating a draft times out, blindly repeating the action could create a second draft. Our design can attach a unique operation key and look up the recorded result before retrying. The exact mechanism depends on the service; the principle is to reconcile uncertain outcomes.

There is nothing glamorous about checking whether a draft already exists. There is also nothing glamorous about explaining why the customer received the same message six times. Choose your glamour carefully.

Keep the state outside the mood of the conversation

A long transcript is a poor substitute for a small, explicit record of the work. Our case record can store the current objective, source identifiers, observations, proposed draft, approval state, tool outcomes, and unresolved questions. A later run should be able to inspect that record and understand what has happened.

This matters when a session ends, a process restarts, or a different component takes over. The model may summarize its previous work, but a summary should not become the sole proof that an external action occurred. Keep the action’s identifier and observed result where the application can check them.

Anthropic’s work on long-running coding agents illustrates the value of persistent progress artifacts and explicit checks between sessions. Our support example uses the same general idea in a smaller setting: leave enough reliable state for the next step to begin without guessing.

Give the loop an exit

If the export service is unavailable, another identical call may not help. If the model keeps finding the same missing information, a longer conversation may only make the bill more interesting. Every workflow needs a way to recognize that progress has stopped.

Our first version might allow two attempts for a transient read failure, then route the case to a person with the partial evidence attached. Those numbers are example settings, not recommended defaults for every system. The right limits depend on the task, the tool’s failure behavior, and the consequences of waiting.

Define the terminal states in language the operator understands: draft ready, more information needed, action awaiting authorization, or stopped after a tool failure. Avoid a single “done” label that hides the difference between a completed task and an abandoned attempt.

Time and cost limits belong in the application that runs the workflow. A sentence asking a model to be efficient is not a spending control. The surrounding software must track usage, enforce limits it can enforce, and stop launching work when those limits are reached.

Put the human where a decision exists

Human review is useful when the reviewer can see a concrete choice. “Approve?” asks for attention without explaining the decision. “Send this exact response to this customer, based on these records?” gives the reviewer something to assess.

The review screen for our example should put the proposed message next to the evidence summary and any uncertainty. It should show whether a repair was actually performed or only recommended. It should let the reviewer edit the draft, reject it, or ask for more information.

This is also where we resist becoming the site’s favorite character: the person who contributes a click and borrows the system’s confidence. A useful reviewer brings context the system may lack and notices where the evidence does not support the conclusion. If the design gives that person no time or information to do the job, the approval step is mostly theater.

Start with an outcome you can inspect

The first release of our support workflow does not need a cast of specialist agents. It needs a set of representative cases and a clear way to evaluate what happened. Include ordinary requests, incomplete records, access failures, stale exports, and complaints the available tools cannot resolve.

For each case, inspect the resulting draft and its evidence. Did the workflow identify the right account? Did it preserve uncertainty? Did it avoid claiming an action that never occurred? How much editing did a person need to do? How long did it take, and what resources did it use? These questions turn a promising demo into work you can compare and improve.

Later chapters will make those checks more systematic. We will design tools, build a bounded loop, track state, test failures, and decide when additional agents are worth their coordination cost. The same example will grow as the requirements grow.

Your first exercise

Choose one recurring task you understand well. Write six sentences: the outcome you want, the information needed, the actions allowed, the actions excluded, the evidence of completion, and the condition that should stop the work or bring in a person.

Then walk through one ordinary case and one awkward case. The awkward case might have a missing record, conflicting instructions, an unavailable tool, or an action whose outcome is uncertain. If your brief cannot explain what should happen, improve the brief before adding more autonomy.

You now have the beginning of an agentic workflow. The next chapter will turn that brief into a contract the system can follow. You may still want to click “make it better.” We will give the system something more specific to work with.

Where the book goes next

A proposed twelve-chapter route from a first workflow to an operation you can inspect, improve, and trust.

  1. The prompt is only the beginning
    Follow one realistic support request from an attractive AI answer to a verifiable result. Introduce goals, tools, state, checks, and responsibility.
    Build along: Draw the current process and mark the decisions.
  2. Give the job a shape
    Define the outcome, inputs, constraints, tool permissions, stopping conditions, and evidence of completion. Turn a vague request into an executable brief.
    Build along: Write a one-page workflow contract.
  3. Choose the simplest useful flow
    Compare a single model call, a fixed chain, routing, parallel tasks, and a model-directed loop. Choose by the uncertainty in the work.
    Build along: Build a small decision table and justify one architecture.
  4. Tools are where words become actions
    Design tool inputs and outputs, validation, access boundaries, dry runs, and readable errors. Separate proposing an action from executing it.
    Build along: Specify a draft-creation tool and its failure responses.
  5. Context is working memory
    Select evidence, track provenance, separate instructions from retrieved material, and keep durable state outside the conversation when needed.
    Build along: Create a compact case record with source references.
  6. Build a loop that knows when to stop
    Implement observation, selection, execution, and checks. Set limits on steps, time, and spending, and recognize repeated failures.
    Build along: Create a bounded single-agent loop with explicit terminal states.
  7. Put human judgment where it matters
    Design review around concrete decisions, with the proposed action and relevant evidence together. Make authorization useful and proportionate.
    Build along: Build an approval view a busy reviewer can actually evaluate.
  8. Design for the day it fails
    Handle timeouts, stale data, partial completion, ambiguous tool results, duplicate requests, and recovery after interruption.
    Build along: Inject a failure and recover without duplicating a side effect.
  9. Measure the work, not the confidence
    Define task-level success criteria, test representative and difficult cases, inspect traces, and measure human rework alongside cost and time.
    Build along: Create an evaluation set and a release decision rubric.
  10. When one agent becomes a team
    Add specialists only when a task benefits from independent work or distinct context. Make handoffs, ownership, and aggregation explicit.
    Build along: Compare one-agent and multi-agent designs on the same task.
  11. Ship a workflow people can trust
    Connect the full process, introduce staged rollout, monitor outcomes, and make recovery available to the operator.
    Build along: Ship a small support-draft workflow with observable outcomes.
  12. Keep the system worth using
    Revisit assumptions as models, prompts, tools, and users change. Remove complexity that no longer earns its place.
    Build along: Write a maintenance plan and a retirement rule.
← Back to MeaxyBack to the top