From tasks to goals

LangChain CEO and co-founder Harrison Chase has published a post describing a shift in how agents are used: away from handing them discrete tasks and toward assigning them goals that they pursue over time. The piece, titled "From tasks to goals," contrasts examples such as writing an email, drafting a blog post or fixing a bug with broader aims like maintaining a blog, making a product successful, or reducing someone's coordination burden while keeping important commitments on track.
Chase frames the change as two practical moves: specifying an outcome instead of an action, and replacing a bounded assignment with an ongoing responsibility. That, he writes, alters what an agent does, what it needs, how it is built and how people interact with it.
The first consequence is that the agent, not the user, chooses the tasks. Given a goal, it decomposes it into a task list, executes some items, updates the list and iterates toward the outcome. Chase says this demands new context engineering and prompting strategies, and that the agent must be reasonably creative and varied in brainstorming tasks rather than repeatedly proposing the same ones. His practical recommendation is a visible to-do list so users can see what the agent is doing, plus prompting that encourages creative task generation.
Tool usage becomes far less predictable. With a task, the developer has a good idea which tools will be called; an email request implies a mail tool and perhaps a calendar. With a goal like reducing coordination burden, it is unclear whether the agent will need email, text messaging, search, a browser or other tools at any given moment. Chase's takeaway is that builders need stronger controls over which tools an agent may or may not call.
Human contact changes too. In a task-based interaction the user is naturally in the loop and can answer follow-up questions in chat. A goal-running agent may work in the background and need clarification at unpredictable moments, so it needs a channel to ask, whether through Slack or a dedicated interface. Builders therefore need a mechanism for background agents to request clarification.
Progress assessment is another new requirement. Chase suggests agents can check a metric to see whether it is improving or collect explicit human feedback, and notes that metric-driven tracking is easier to automate but that blindly optimizing a single number is unwise, which makes human feedback potentially the better option. Goals should be designed so feedback is easy to give, with both metrics and a way for users to correct the agent's interpretation of success.
Because ongoing work is not always running, it needs triggers to wake the agent. Chase lists heartbeats at fixed intervals, recurring cron jobs, one-off cron reminders and listening to an event stream. Equally important are stopping rules: an agent pinged every thirty minutes should not ask the same question each time, and an ongoing responsibility does not mean the agent must always find something to do. Sometimes doing nothing is correct, so builders need both triggers and prompting that lets the agent decide when to act.
Memory, in Chase's view, has been less necessary in a task-based world because users supply relevant context each time, except when repeating the same task. As responsibility is delegated, that burden shifts to the agent, which must carry decisions and feedback forward. Rejecting a blog topic, for example, should inform future topic selection rather than just the current draft.
Chase closes by arguing that giving an agent a goal is not simply a bigger prompt. It delegates decisions about what work to do and when, and moves the user's role toward setting direction, defining boundaries and reviewing progress. The post sits alongside related LangChain material on goal design, context engineering and managed agents, and points to LangSmith, the company's agent engineering platform, for debugging agent decisions, evaluating changes and deployment.
Read together, the post reads as a checklist for teams moving beyond single-shot automation. The elements it names — planning loops, tool permissions, clarification channels, feedback capture, scheduling and cross-run memory — are largely engineering problems rather than prompting tricks, which suggests the hard work of goal-oriented agents sits in the surrounding harness and observability layer. A likely trade-off is that broader goals buy flexibility at the cost of predictability: the same openness that lets an agent choose useful tasks also makes its tool calls harder to audit in advance, which raises the value of the visibility and control mechanisms Chase recommends. How well goals can be tied to measurable outcomes without encouraging narrow metric gaming remains an open design question for product teams.
Why it matters: Teams building agents will need infrastructure beyond a model and a prompt — scheduler triggers with stop conditions, scoped tool permissions, an inbox for clarification and persistent memory — and product decisions about how users express goals and review progress. Developers should expect agent UX to look more like supervising ongoing work than issuing commands, and should plan for evaluation and observability tooling accordingly. That is my inference from the requirements Chase lays out, not a claim he makes about specific products.
Based on reporting from the original publisher. Visit the source for full context and later updates.
Publisher excerpt
LangChain CEO and Co-founder Harrison Chase shares how we're moving from task-specific agents to goal-focused agents. Learn more.