PracticeAgents & Tool Use
Goal Engineering
At a glance
Designing what an AI agent is meant to finish, how a person can review that finish, and what the agent may not do on the way.
- Who this is for
- Engineers and technical readers learning the terms used in AI systems.
- Topics
- Agents & Tool Use
- Practice
In short
Goal engineering is the emerging practice of designing what an AI agent is meant to finish, how a person can review that finish, and what the agent may not do on the way. Bigcircle writes a checkable done-condition, keeps guardrails in code the agent cannot edit, and puts an eval gate in CI before a harness change merges. Our harness engineering work is where that verify step lives.
Key facts
Definition
Goal engineering is designing an agent's goal and scope so a person can review the finish, a check can say when the work is done, and a mandate can say what the agent may not do on the way, with the term still loose among builders as of November 2026.
How Bigcircle does it
- On Solarpunk, Bigcircle's executive operations agent, a critic decides after every step whether to continue, retry or escalate, and the run compares what the agent claims it finished with the real state of the application.
- On Skionis, Bigcircle's DevOps agent on a live AWS account, a validation loop checks each template against the account before an engineer approves it, and a template that will not come clean after bounded revision goes to a person.
- Bigcircle keeps the eval gate, the permission scope and the trace outside anything a loop can edit, and a harness change found in traces clears the eval suite in CI before it merges.
Comparison
Prompt engineering changes the wording of one request, context engineering changes what the model reads on one turn, harness and loop engineering change the runtime around and between runs, and goal engineering decides what finished looks like before those layers are tuned.
Key number
On Skionis, template errors before deploy fell from around 10% to 4% once a validation loop sat in front of the engineer's approval, which is the same shape as a checkable done-condition with a human stop.
Goal engineering is the emerging practice of designing what an AI agent is meant to finish, how a person can review that finish, and what the agent may not do on the way there. The phrase spread on X in November 2026 after Harrison Chase struck through context engineering and harness engineering and wrote goal engineering. Builders still disagree on what the term covers, so treat the readings below as competing takes rather than a settled definition.
Sydney Runkle at LangChain put the shift in one line: "agent working on tasks in service of a goal >> agent working on task". A task is a step; a goal is the finish those steps serve, and the review surface around that finish. Keep that distinction when you name the work, or you will tune a task prompt while the finish stays undefined.
What is goal engineering?#
Three readings are in play as of mid-November 2026, and they pull the phrase in different directions rather than settling it. Use them as a checklist, not as three schools you have to pick between.
The first reading is about scope and feedback. @mgarimella and the X Article written with Harrison Chase frame goal engineering as designing an agent's goal and scope of work so humans can review it and give feedback. Agents fail mostly from missing tacit context: taste, judgment and other knowledge that is not already written down. Actively split agents by sales motion, such as outbound, rather than by customer, so feedback on one task carries across similar tasks, which is the reading @Xudong07452910 also summarised.
Design the scope around the review you can actually give, or the tacit context never reaches the agent.
The second reading is about checkable done-conditions, close to eval design. @bymichaelliang writes "Goal engineering is eval design with a new name... an agent can only chase a goal you can check". @coderfrankfurt asks "can you check done cheaply?", and @benjiminu puts it as mostly writing "done when" and "stop and ask when". Write that check before you expand the agent's autonomy, or the agent invents a pass you never meant.
The third reading is the trade-off between the target metric and unmeasured guardrails or mandates: what the agent may not do to get there. @jeffrschneider treats goal engineering as an exercise in trade-off analysis. @SingulantChain separates a goal from a mandate: the goal names what to achieve, and the mandate names what the agent may not do. Put the mandate in code the agent cannot edit, or a higher pass rate will teach it to weaken the check.
We hold those three as one checklist. Write the finish a person can review, write the check that says the finish happened, and write the rules the agent cannot rewrite on the way. If any one of those is missing, the agent invents its own definition of done, and you find out only at review time.
Where did goal engineering come from?#
Harrison Chase (@hwchase17) posted on 11 November 2026 with context engineering and harness engineering struck through, and goal engineering written underneath. On 14 November 2026 he and @mgarimella posted the X Article Goal Engineering: How to Design Goals. That is the origin trail for the phrase as builders are using it this month.
The meaning is still loose. Treat those posts as readings of the phrase, not as a standards document. Keep the checklist in your own harness rather than waiting for one definition to settle.
How does goal engineering relate to prompt, context, harness and loop engineering?#
Treat the names as a map of layers, not as rival brands with separate job titles.
Prompt engineering changes the standing instructions and the wording of one request. Context engineering changes what the model reads on one turn: the documents, tool results and history that fill the window. Harness engineering is the runtime around one run: context assembly, tools, state, permissions and the check that finished work actually happened. Loop engineering is the part of that runtime that deals with repetition: verification, event triggers and harness changes from traces across runs.
Goal engineering sits above those layers. It decides what the agent is chasing and how a person judges the finish, before you rewrite the prompt or the loop. A sharper prompt cannot fix a goal with no check. A new loop cannot fix a goal that a person cannot review. Find the missing layer before you spend another week on the wrong one.
How Bigcircle handles goal engineering#
The work the phrase points at already sits in how we ship agents, under older names.
On Solarpunk, the executive operations agent we built, a critic decides after every step whether to continue, retry or escalate, and the run compares what the agent claims it finished with the real state of the application. Our guide on why agents report unfinished work as done is the long form of that rule: decide before the action what finished looks like, read it back from the system the action changed, and treat anything you could not read as unknown.
That guide also cites a 2026 measure across coding-agent sessions where inaccurate self-reporting appeared in 22.58% of the validated misalignment episodes. We treat every claim of done as unverified until the target system agrees for that reason.
On Skionis, the DevOps agent we shipped on a live AWS account, a validation loop runs structural and semantic checks against the account before anything is applied, and a template that will not come clean after bounded revision goes to a person. Template errors before deploy fell from around 10% to 4% once that loop sat in front of the engineer's approval.
Our harness engineering work puts a verify step and an eval suite in CI in front of a merge, so finished is checked rather than believed. In week 1 of that engagement we instrument the loop you already have: we trace a real run end to end before changing anything. In week 1-3 we fix context and tools first: assembly and compaction, then schema-enforced tool output with a repair path. In week 3-6 we put a gate in front of it. Permission scopes and guardrails stay in code the agent cannot edit: input schemas, output constraints, and a written rule for what must never happen. Human-in-the-loop checkpoints stay wherever the stakes justify a second pair of eyes. That is the same checklist the three readings above ask for, written in the client's codebase rather than in a new slogan.
How do you write a goal an agent can check?#
Start with the finish a person would accept, then make that finish machine-checkable where you can so the agent is not inventing its own pass.
Write "done when" as facts you can read from a system: tests pass, a record exists, a status field flipped, a citation resolves. Write "stop and ask when" as the states the agent must not guess through: missing permission, conflicting evidence, a vendor that is down, a judgment call about tone or risk. Put both outside the prompt when the stakes are high, in a check the agent cannot argue past. Our evals page starts that suite at 20 cases to 50 cases drawn from real failures, because early changes tend to have large effects a small set can see.
Keep the mandate beside the goal. A pass rate with no "may not" list teaches the agent to weaken the check. We keep the eval gate, the permission scope and the trace outside anything a loop can edit for that reason, as the loop engineering page already sets out.
Skip a heroic goal while the work is still a short workflow with steps you can write down. Write the steps, put a check at each one, and leave open-ended goal chasing for the parts that still fail after the path is fixed. An agent that runs a few times a month will not produce enough reviewed finishes for tacit feedback to compound either. Spend that effort on the verification check first.