---
title: "What Is Goal Engineering? LangChain's Idea Explained"
url: "https://goremy.ai/blog/articles/goal-engineering-langchain-explained"
author: Luis Chavez-Mattos
editor: Luis Chavez-Mattos
editor_title: Director, Product
published: "2026-11-18T04:20:09.324Z"
updated: "2026-11-18T04:20:09.324Z"
topic: AI Agents & Automation
description: "Goal engineering explained: how Actively AI scoped agents around human review speed, and why one correction can upgrade a whole fleet of agents."
---

# What Is Goal Engineering? LangChain's Idea Explained

> Goal engineering explained: how Actively AI scoped agents around human review speed, and why one correction can upgrade a whole fleet of agents.

Edited by Luis Chavez-Mattos, Director, Product · Published 2026-11-18

## What is goal engineering?

Goal engineering is LangChain's name for the work of setting up an AI agent with a long, open-ended goal so that a human can quickly check what it produces and teach it what "good" looks like. The central rule: scope each agent around how fast a person can review its output, not around how your data or database happens to be organized. The point is to capture human judgment and taste, which is the hardest context to give an agent.

## TL;DR

- Goal engineering is about **giving agents human judgment**, not only documents and tools, when there is no unit test that says whether the work is right.
- In LangChain's case study, Actively AI first built **one agent per customer account**, and it broke because people hated reviewing many different task types spread across separate agents.
- The fix was to **slice the goal horizontally**: each agent owns one repeatable job across every account.
- **Background agents gather the objective data** (the facts), so the reviewed agent can focus on the part that needs judgment.
- When the output is uniform, a person can grade about **20 similar drafts in two minutes**, and one correction improves the whole fleet.
- The practical rule: **scope by review speed**, not by database schema.

## Why does goal engineering exist at all?

Agents are increasingly pointed at goals with no clear finish line. "Write good outreach to these accounts" or "keep this pipeline healthy" has no test that returns pass or fail. A coding agent can run unit tests and know when it is wrong. An agent doing open-ended work cannot.

What fills that gap is a person. The agent needs to know what your team considers a strong draft, a risky claim, or an account worth skipping. That knowledge sits in people's heads, and it is hard to write into a prompt up front. It tends to show up when someone reads an output and says "no, not like that."

So the design question changes. It is no longer only "what does the agent need to know?" It becomes "how do we make it cheap and fast for a human to tell the agent what it got wrong?"

## How is goal engineering different from prompt, context, and harness engineering?

The terms stack up like this:

| Term | What it focuses on |
|---|---|
| Prompt engineering | Wording the instructions you give a model |
| Context engineering | Choosing what information the model sees (docs, data, tools) |
| Harness engineering | The scaffolding around the model: tools, loops, and controls |
| Goal engineering | Structuring the objective so human judgment can flow into the agent |

The commentary on this idea was openly skeptical of the constant renaming. Software people have coined a new "engineering" every few months. But the same commentary pointed to one real architectural lesson underneath the label, and that lesson is worth keeping whatever you call it.

## What went wrong with the first Actively AI agent?

In the case study, Actively AI first built one agent for each customer account. That sounds sensible. Each account has its own data and its own context, so give each one its own agent.

It broke, and the cause was not a weak model. There were two problems:

1. **Reviewing was miserable.** A person had to look at about ten different types of tasks scattered across separate agents. Switching between task types is slow. Every review needed a fresh mental setup.
2. **Nothing transferred.** When a human corrected one agent, the other agents learned nothing. The same mistake had to be fixed again in each one.

Both problems have the same root. The agent was divided along the lines of the data (one account, one agent), not along the lines of the human's work.

## What does it mean to slice the goal horizontally?

Actively AI changed the cut. Instead of one agent per account doing everything for that account, they gave each agent one repeatable job and ran it across every account.

Here is an illustration, not taken from the case study. Say a team handles 50 customer accounts, and the work for each includes a research summary, a follow-up email draft, and a risk flag.

- **Vertical (by account):** 50 agents, each producing a summary, an email, and a flag. A reviewer jumps between three kinds of output for one account, then repeats for the next.
- **Horizontal (by job):** one agent writes all 50 follow-up emails. Another produces all 50 risk flags. The reviewer reads 50 emails in a row, in one frame of mind.

The source describes the payoff directly: a human can grade 20 similar drafts in two minutes. Similar outputs let you spot patterns fast. You see that the opening line is too stiff in all of them, or that a claim keeps appearing that nobody can back up.

## What are background data agents, and why separate them?

Splitting by job raises a question. If one agent owns "the follow-up draft," where does it get the facts about each account?

In the case study, background agents gather the objective account data. These agents collect facts that are either right or wrong and do not need taste to judge. The reviewed agent then takes that data and does the part that requires judgment.

This separation matters for review. A human should not spend two minutes of attention checking whether a figure was copied correctly. Factual gathering can be checked in other ways, or trusted once it is set up. Human review time is limited, so it should go to the work where only a human can decide: tone, priorities, what to say and what to leave out.

## Why can one correction upgrade the whole fleet?

Because the correction lands in one place that every account passes through.

If a reviewer notes "never lead with a discount" or "keep it to three sentences," and one agent writes all the drafts, that change applies to every account on the next run. In the per-account design, the same note had to be repeated across many agents, and in practice it often was not.

This is the compounding effect of goal engineering. Each review does two things at once. It fixes the batch in front of you, and it improves every future batch.

## How do you scope an agent by review speed?

The rule is to scope around how fast a human can review the output, not around your database schema. A schema describes how data is stored. Review speed describes how people work. These rarely line up.

Try this process when you design an agent:

1. **List the outputs a person must approve.** Not the steps the agent takes, only the things a human will read and judge.
2. **Group outputs by type.** Emails with emails, summaries with summaries, flags with flags.
3. **Give each type its own agent.** One repeatable job per agent, running across every account, candidate, ticket, or project.
4. **Move objective facts to background agents.** Anything that can be right or wrong without taste goes upstream.
5. **Time a review.** If a reviewer cannot get through a batch of similar items in a couple of minutes, the output is too varied or too long. Split it again.
6. **Give corrections one home.** Make sure feedback goes to the agent's shared instructions, not into a single item.

A note format that makes corrections reusable:

```
Correction for: [agent name]
What I saw: [pattern across several drafts]
Rule going forward: [one sentence]
Example of good: [paste one]
Example of bad: [paste one]
```

## Is goal engineering just a buzzword?

Partly, and the source says so itself. The name is new and probably will not last. The lesson underneath is plain: an agent working on an open-ended goal needs human taste, and the structure of your agents decides how cheaply that taste can reach them.

Also note the limits of what we know. The case study, as summarized here, gives the pattern and the "20 drafts in two minutes" figure. It does not give details like error rates, time saved, or how many accounts were involved, so treat the pattern as a design principle, not a proven benchmark.

## What does this mean for you?

**If you manage a team using AI agents or assistants:** look at how your people review output. If they bounce between different kinds of tasks, you have the account-by-account problem. Reorganize around the type of output so reviews are batches of similar things.

**If you build or configure agents (even with no-code tools):** resist splitting by customer, region, or folder just because the data is split that way. Split by the job a person has to judge.

**If you are an individual using AI for repeated work:** keep one standing set of instructions per type of task (one for follow-up emails, one for meeting summaries) and update it every time you correct something. That is goal engineering at personal scale.

**If you are in recruiting, sales, support, or finance:** your judgment is the valuable input. Expect to spend less time producing first drafts and more time grading and correcting them. Getting good at writing clear, reusable corrections is a skill worth building.

## Could I build a review queue like this myself?

A review-by-batch setup needs a small app: a list of drafts from one agent, a way to approve or edit each, and a place to store the correction rules. If you would rather not wire that together from spreadsheets and email threads, [Remy](https://goremy.ai) can build it from a plain-English description. You could describe a queue where one task agent drafts the same kind of item for every account, reviewers sign in with role-based access, and corrections save to a shared instructions page. Remy builds the database, login, and hosting, and the app is standard TypeScript in a git repo you own.

## Frequently Asked Questions

### What is goal engineering in simple terms?

It is designing an agent's objective so a human can review its work fast and teach it what good looks like. The goal is to get human judgment into the agent, which is hard when there is no test that checks the work.

### Who came up with goal engineering?

LangChain introduced the term, along with a case study about Actively AI. Some commentators note it follows prompt, context, and harness engineering, and treat the name as a buzzword while agreeing that the underlying lesson is useful.

### Should I use many small agents or one big agent?

Choose based on review, not on data layout. Give each agent one repeatable job whose outputs look alike, so a person can grade a batch quickly. Let separate background agents gather objective facts.

### Does this only apply to sales or account work?

No. The case study involved customer accounts, but the principle applies anywhere an agent produces many similar drafts that a person must approve, such as candidate notes, support replies, or report summaries.

### How do I know my agent is scoped well?

Time a review. If a person can grade a batch of similar outputs in a couple of minutes and one correction visibly improves the next batch, the scope is working. If reviews feel scattered and the same fixes keep coming back, split the work differently.
