LangChain's 'Goal Engineering': Scope Agents So Feedback Is Cheap — and Qwen Code's Shipped Goals Show the Pattern
LangChain names the discipline 'goal engineering': scope agents so human feedback is cheap. Qwen Code's shipped Goals feature shows the pattern arriving in coding CLIs. Here is what operators should do with it.
The agent world spent 2025 on prompt engineering and 2026 on context engineering. LangChain’s Harrison Chase now argues the next durable discipline is neither: it is goal engineering, the practice of designing what an agent optimizes so that a human can teach it while it runs. In a post published Nov. 14, co-written with Mihir Garimella and Anshul Gupta of Actively AI, Chase’s claim is blunt: “Prompt engineering and context engineering will disappear, but goal engineering will remain.”
The argument matters to anyone operating Claude Code, Codex, OpenCode or Qwen Code fleets, because the shift it describes — from single-turn tasks to open-ended goals an agent drives toward completion — is already landing in shipped coding tools. Qwen Code v0.27.4, released Nov. 15, extends its Web Shell Goals page to merge goals across trusted workspaces. And its overview documentation pitches Qwen Code as a composable, scriptable terminal agent — exactly the kind of unattended lane where a goal, not a prompt, becomes the unit of work.

The core rule: scope for feedback, not for data
Chase’s central learning from building goal-oriented agents is a design rule operators can apply immediately: design the agent’s scope so it is as easy as possible to give feedback within that scope.
The reasoning: when agents fail, the usual cause is missing context. Some of it is easy to fix — documents, API access, written-down facts. The trickiest context is what exists only in a human expert’s head: taste, tone, how aggressive to be, what “good” looks like. The only way to deliver that context is as feedback while the agent works. An agent that cannot absorb that feedback quickly becomes useless on subjective work.
That reframes the operator’s job. The bottleneck is not the model; it is “them learning from feedback.” Chase recommends investing heavily in a review UX — batching similar work together so one correction teaches many tasks — because that is where agent performance is actually won.
The Actively AI case: why per-account agents failed
The post’s case study is the sharpest part. Actively AI, which builds sales agents, first deployed one agent per account (a prospective customer), each with the goal of moving that account forward. It sounded right: constrained goal, clear outcome.
Two problems emerged. Salespeople had to context-switch between many agents with only a few items to review in each. And the hardest-won knowledge — how to outbound, how aggressive to be, how to navigate a large org — was being learned separately inside each account-bound agent, with no way to transfer it.
The second version inverted the boundary. Agents became “motions” — jobs to be done, like outbounding or early-stage deal progression — that work across many accounts. Because a motion is a bunch of similar tasks, a salesperson reviews them together, and feedback on one task transfers to the rest. Objective account facts still matter, but those are gathered by background context agents; the subjective judgment lives in the motion agents that learn from review. This is the pattern: align the agent boundary with the thing a human can review in one sitting.
Goal-driven sessions are already in coding CLIs
This is not just vendor theory. Qwen Code’s v0.27.4 release notes list among the highlights: “Web Shell Goals page can merge goals from trusted workspaces, show workspace badges, and target a selected workspace when creating goals (#17230).” The same release ships fixed-interval /loop schedules for Managed Sessions, memory-import SDK APIs and tighter Auto Mode authorization — the surrounding machinery an unattended, goal-oriented lane needs. The overview docs frame Qwen Code as a Unix-philosophy tool your CI can drive headlessly, which is precisely where goal objects have to live.
In other words, the pattern LangChain is naming — hand an agent an open-ended goal, let it run, review its work against that goal — has a shipped implementation in a production coding CLI, evolving quickly enough that goal status messages, multi-workspace merging and completion review are the subject of individual PRs.
What operators should do with this
- Redraw one boundary this week. Find a lane where you run one agent per ticket, repo or customer. Ask what feedback you keep repeating across those agents — that repeated correction is the signal that the boundary is wrong, and the work should be grouped by job-to-be-done instead.
- Budget for the review UX, not just the prompt. If your reviewers context-switch between dozens of sessions with two items each, you are paying the per-account tax Actively AI diagnosed. Batch similar agent output into one review queue.
- Write goals a transcript can prove. An open-ended goal still needs a checkable finish line; for the unattended-lane version of this discipline, see Write a Finish Line the Transcript Can Prove.
- Pair goals with bounded autonomy. Goal-driven sessions run longer and touch more surface. Qwen Code’s own release cadence shows the pairing: multi-workspace goals shipped in the same release as stricter Auto Mode authorization checks. If you adopt goal lanes, harden the permission model at the same time — the lesson from Qwen Code v0.26.5’s human-handoff limit generalizes.
- Treat feedback as extracted context. The knowledge your experts hand over during review is the asset. Log it, structure it, and feed it back into the agent’s instructions — that loop is the whole point.
The honest caveats
Chase’s rule is drawn from LangChain’s own agent work and one detailed sales case; it is a strong pattern, not a measured result. And Qwen Code’s Goals feature is documentation and release notes, not an independent evaluation — operators should pilot one motion-style lane before redrawing a fleet. But the direction is consistent across both vendors: agent scope is becoming a design surface, and the unit of design is what a human can review in one pass. That idea sits naturally inside the broader harness engineering discipline: the harness, the goal and the review loop are one system, and the goal is where the human enters it.