AI Made Friendly HERE

LangChain Says Prompt Engineering Will Disappear. Here’s What Comes Next

On November 14, 2026, LangChain published a post that ends with a deliberately provocative line: “Prompt engineering and context engineering will disappear, but goal engineering will remain.” The post is co-authored by Harrison Chase and the founders of Actively AI, a sales automation company. Two weeks earlier Chase had published a companion post about context engineering challenges. Reading both together gives you the clearest picture yet of where agent design is heading in late 2026, and where it is still unsolved.

The day before the goal engineering post, LangChain announced a $300 million Series C at a $3 billion valuation. More than 7,000 organizations run on LangSmith, its agent platform. Workday says it cut agent deployment time from five months to under a day. Clay reportedly monitors hundreds of millions of agent runs per month on the platform. The company’s next act is not subtle about it: agents that work toward goals, not agents that take instructions.

The trajectory: from text generation to open ended goals

The post describes the arc in one paragraph. Agents went from simple text generation to tool calling and decision making to executing full tasks. The next stage is open ended goals, where the agent drives toward completion on its own. Chase’s example is Hone, which raised a $60 million seed round from Benchmark and Index Ventures. Hone’s framing is stark: “An Engine meets goals rather than completing tasks.” You assign it an outcome like improving customer retention, it learns the company, and it owns the outcome. A key part of the setup, Chase notes, is defining metrics for the agent to optimize.

That is the whole shift in one sentence. Step by step instructions tell the agent what to do. A goal tells it what to achieve and leaves the how open. The design problem moves from prompting to scoping: what is the goal, what does done look like, how does the agent stay pointed at the right thing?

The core argument is feedback, not benchmarks

The central claim in the post is about feedback. You want to design the scope of an agent so that giving feedback on its work is as easy as possible. The reasoning: when agents mess up, the usual cause is missing context. Some context is cheap to supply, like access to documents and APIs. The expensive kind is context that is not written down anywhere: taste, judgment, risk tolerance, what good looks like in a specific organization. That context only enters the agent through feedback from a human expert.

The marketing example in the post makes it concrete. An agent that optimizes ads for marketing performance needs more than data. It needs taste: what sounds and looks good, how provocative the brand can be. An agent that cannot absorb that feedback becomes useless quickly.

The blunt version, quoted directly: “The bottleneck for agents performing is often them learning from feedback.” The design consequence is that the review interface is a production constraint, not a nice to have. If learning from feedback is the bottleneck, you optimize the ease of giving feedback.

The most concrete implementation of goal engineering is in Deep Agents Code, LangChain’s terminal coding agent. The docs define a goal as one measurable objective where the agent drafts its own acceptance criteria before starting.

The workflow is simple:

/goal add OAuth refresh handling

The agent drafts acceptance criteria and opens them for review. Once accepted, the goal stays active across turns until it is paused, completed, blocked, or cleared. Full lifecycle commands: /goal amend, /goal pause, /goal resume, /goal show, /goal clear, plus controls for the grading model and maximum grading iterations. Every follow-up turn is graded against the goal’s acceptance criteria until the work is done.

A longer session shows the pattern:

/goal migrate auth callbacks to the new API
start with the OAuth callback
now update the tests
check the docs too

You steer by goal, not by re-explaining the task.

Rubrics are the other half. When you already know the criteria, you state them: /rubric set “tests pass; no unrelated files changed; help text is updated”. Rubrics can apply to the next turn only or persist across turns. Non interactive runs use flags, for example dcode -n “implement OAuth refresh handling” –rubric “tests pass; no unrelated files changed” –rubric-max-iterations 3.

Two mechanisms matter. The agent drafts its own definition of done and a human approves it before work starts. And the criteria survive across turns, which is what makes long horizon work possible: the goal, not the accumulating chat instructions, grades each step.

The loop pattern is older than the name

The planner loop underneath all this shipped in February 2024. LangGraph’s plan and execute agents split work into a planner that produces a multi step plan, executors that run each step, and a replan step after execution. The design draws on Plan and Solve Prompting and Yohei Nakajima’s BabyAGI.

The motivation was practical. ReAct style agents call the LLM once per tool invocation and plan one step ahead. A planner forces the model to think through the whole task first, which improves task completion rates. It also cuts cost: individual steps can run on smaller, domain specific models. LLMCompiler, the third architecture in that release, streams a DAG of tasks and schedules each one as soon as its dependencies are met; the paper claims a 3.6x speedup.

The goal loop is the same shape with a definition of done added. In LangGraph, it looks like this, following the documented plan and execute example with a criteria check:

from typing import Annotated, TypedDict
import operator
from langgraph.graph import StateGraph, END

class GoalState(TypedDict):
objective: str # the goal, not the steps
criteria: list[str] # acceptance criteria
plan: list[str] # current plan
completed: Annotated[list[str], operator.add]

def planner(state: GoalState) -> dict:
return {“plan”: plan_for(state[“objective”], state[“criteria”])}

def executor(state: GoalState) -> dict:
step = next_step(state[“plan”], state[“completed”])
return {“completed”: [step], “result”: run(step)}

def replanner(state: GoalState) -> dict:
if criteria_met(state[“objective”], state[“criteria”], state):
return {“plan”: []}
return {“plan”: plan_for(state[“objective”], state[“criteria”], state[“completed”])}

workflow = StateGraph(GoalState)
workflow.add_node(“planner”, planner)
workflow.add_node(“executor”, executor)
workflow.add_node(“replanner”, replanner)
workflow.set_entry_point(“planner”)
workflow.add_edge(“planner”, “executor”)
workflow.add_edge(“executor”, “replanner”)
workflow.add_conditional_edges(
“replanner”,
lambda s: “planner” if s[“plan”] else “end”,
{“planner”: “planner”, “end”: END},
)

The functions plan_for, next_step, run, and criteria_met are illustrative stand-ins. The graph structure is the point: the goal and its criteria live in state, the planner re-derives steps from them, and the loop ends only when the criteria pass.

The case study: Actively AI’s motions

Actively AI builds agents for sales teams. Its first goal-oriented design ran one agent per account. Each prospective customer got an agent tasked with moving that account forward and producing actions for sales reps to approve. It seemed natural: the account is the obvious unit of context.

It failed in a specific way. Progressing one account involves many different jobs spread out over time, so at any moment there were only a few things to review per agent. Salespeople switched constantly between agents. And the most valuable knowledge, how to outbound, how to reply, how to strategize a deal, how aggressive to be, was scattered across every account agent. Feedback learned on one account had no path to the others, even when the lesson applied to all of them.

The rewrite changed the unit of work. Actively built agents called motions on top of LangChain’s Deep Agents. A motion is a job: outbounding, early stage deal progression. A motion covers a batch of similar tasks, so a salesperson reviews them together, and feedback on one task transfers to the whole motion. Account context, which is mostly objective and already written down, is assembled by background context gathering agents. The work agents own the slice of the sales motion and pull in account context as needed.

That is the pattern in miniature. The account looked like the right boundary. The motion was the right boundary, because it made review cheap and feedback reusable.

The unsolved half: agents can cheat

The companion post from November 2, 2026 is more honest about open problems. Goal tracking is hard: getting agents to try new experiments in pursuit of a goal instead of repeating what worked, getting them to think about broad goals instead of small tasks, keeping them consistent over long time horizons.

Then there is alignment. “Goal design is hard by itself. It will be very hard for users to design goals that agents can not cheat.” The classic example: tell an agent to get rid of all bugs in a codebase, and it may delete the codebase, because no code means no bugs. This is specification gaming, a concept DeepMind documented. The open question is how to build a harness that keeps an agent focused on a goal without letting it over optimize. Chase is explicit that nobody has general solutions yet.

What the threshold claim actually means

Why should goals beat step by step instructions in general? The meta argument across the two posts: instructions encode how someone once thought the work should be done. They go stale, and correcting them means editing the instruction, which is slow and keeps the agent dependent on the instruction giver.

A goal plus a review loop encodes only the outcome and the corrections. The feedback channel keeps working as the world changes. Knowledge gets extracted from the human expert and stays in the loop, not in a prompt. That is the sense in which goal engineering remains: the feedback loop is the part that keeps functioning.

The claim that prompt engineering and context engineering will disappear is the promotional half. Prompting and context still decide whether the agent can even attempt the goal. The November posts themselves are full of context engineering concerns, from memory to browser use to async subagents. What is changing is the center of gravity, from writing instructions to designing goals and their review loops.

What to take from this

The practical thesis has four parts. Scope agents around review, not around task boundaries: if a human can review a batch of work in one place, feedback compounds. Make done explicit before work starts: an agent that drafts acceptance criteria and a human approves them is a cheap alignment check before tokens get spent, and Chase names wasted tokens as the cost of pointing agents wrong. Build the review interface seriously: it is the production constraint. Assume the goal will be gamed: metrics are proxies, proxies get overfit, and the question is not whether the agent will cheat but how you will detect it.

The shift is real. The unit of design moves from the instruction to the loop: goal, plan, execute, review, learn. Step by step instructions made the agent an executor of captured process. Goals plus feedback make it a worker that gets corrected into alignment, the way a new hire does. The job of the agent builder changes with it: not writing better prompts, but designing goals a human can review and a machine can be held to.

Whether prompt engineering truly disappears is the wrong question. The right question is which loop wins in production: writing better instructions, or giving better feedback. Everything in the November posts points to the feedback loop.

—

Sources:

  • Goal Engineering: How to Design Goals, LangChain, November 14, 2026: https://www.langchain.com/blog/goal-engineering
  • New context engineering challenges in late 2026, LangChain, November 2, 2026: https://www.langchain.com/blog/context-engineering-challenges-late-2026
  • Goals and rubrics, LangChain Docs: https://docs.langchain.com/oss/deepagents/code/goals-and-rubrics
  • Plan and Execute Agents, LangChain, February 13, 2024: https://www.langchain.com/blog/planning-agents
  • Introducing Engines: AI with Motion, Hone: https://hone.com/blog/introducing-engines/
  • LangChain Raises $300M, LangChain, November 13, 2026: https://www.langchain.com/blog/series-c
  • Specification gaming, Google DeepMind: https://deepmind.google/blog/specification-gaming-the-flip-side-of-ai-ingenuity/
  • deepagents, GitHub: https://github.com/langchain-ai/deepagents

Originally published on zfrqbl.com.

Originally Appeared Here

You May Also Like

About the Author:

Early Bird