What is the difference between a task agent and a goal-driven agent?

Answered by Falk Gottlob · Reviewed · 3 min read

THE SHORT ANSWER

A task agent responds to a prompt: you tell it what to do, it runs, you check if it worked. A goal-driven agent holds an objective over time: you give it a goal, it schedules its own runs, persists state between them, and surfaces a result when it has one. The task-execution pattern is scaffolding for systems too brittle to trust with a persistent objective. When an agent is reliable enough, the right product is a report you read, not a conversation you debug.

The task-execution pattern is not a bug. It is a first version.

It was designed for agents too brittle to be trusted with more. You prompt, the agent runs, you check if it worked. At each step, the human is close enough to catch a mistake before it becomes expensive.

The pattern is appropriate when the agent is new, when the domain is unfamiliar, when the work is non-recurring, or when the human genuinely needs to steer in real time. For the editor, the advisor, the agent exploring something it has not seen before, task-execution is the right shape.

The mistake is treating it as the final form.

What changes with a goal-driven agent

A goal-driven agent holds an objective across time. You give it a goal: maintain the creator scan, monitor the pipeline, track the competitor landscape. The agent schedules its own runs, persists state between them, and decides when it has something worth surfacing.

The product difference is the interaction model. With a task agent, you are in a conversation. With a goal-driven agent, you read a report. The exception, the agent surfacing to ask for input, should be notable rather than routine.

Three things need to be true before an agent is ready to hold a goal:

Ambient scheduling. The agent runs when the work needs doing, not when a human sends a prompt. This is the technical precondition for everything else. Without it, the agent's value resets every time a human remembers to use it.

Persistent state between runs. A stateless agent is the same agent every time. A run-persistent agent remembers what it did last week, what the state of its own work is, and what the context of the domain looks like. The difference between a tool and a system is state.

Outcome verification. An agent that reports completion without evaluating its result is worse than no agent. It trains the human to trust reports they should be checking. The agent needs to hold its own quality bar.

This creator scan is a goal-driven agent. The goal is a digest and four published posts. The scan runs weekly on a schedule. It holds state from the previous run. It evaluates its own output before the results commit. I read the summary. When it fails, I read the failure message rather than debug a conversation.

The model is an implementation detail. The harness is the product.

For the full kill list entry and the week's convergence evidence: Kill the Task-Execution Agent Pattern

SOURCES

THE LONG VERSION

RELATED ANSWERS