xAI Launches /goal in Grok Build, Adding Long-Running Autonomous Execution With Built-In Verification for Multi-Step Coding Tasks

xAI shipped a new mode called /goal inside Grok Build, its terminal coding agent. The feature targets long-running, autonomous task execution. You hand the agent a larger implementation task, then step back.

Most coding sessions require back-and-forth execution and verification. You prompt, the agent acts, and you verify each step. /goal changes that loop. The agent keeps working until a task is completed and verified. Verification can mean reviewing code, inspecting webpages, or executing scripts.

The mode packages that autonomy behind one command and a visible progress checklist.

TL;DR

/goal runs long, autonomous tasks inside Grok Build’s terminal agent.
It plans an approach, builds a checklist, executes, and verifies until complete.
Verification can review code, inspect webpages, or execute scripts.
status, pause, resume, and clear steer the live run.
Access needs a SuperGrok or X Premium Plus subscription.

What is `/goal`

/goal is a mode within Grok Build, not a separate product. Grok Build is xAI’s coding agent and CLI for software engineering. A CLI is a command-line tool that runs in your terminal. It works against your local codebase, reading files and running commands.

Grok Build already ships several agent features. It has a plan mode that blocks edits until you approve a plan. It delegates larger work to specialized subagents that run in parallel. It reads your AGENTS.md, plugins, hooks, skills, and MCP servers out of the box. MCP is a protocol that connects agents to external tools and data.

Access requires a SuperGrok or X Premium Plus subscription. You install the CLI with one command:

curl -fsSL https://x.ai/cli/install.sh | bash

You then sign in with your account and invoke /goal. The mode is built for handoff. You describe one objective, and the agent owns the multi-step work.

Why Long-Running Execution Matters

An agent is given a goal, not just a single prompt. It plans steps, executes them, observes results, and replans when reality diverges. That is the observe–plan–act loop. The trade-off is observability: long runs produce many actions you must monitor. /goal answers that with a progress checklist and steering commands.

How `/goal` Works

You set a goal in a single line. You type it inside the Grok Build session, not your system shell. For example:

/goal Migrate the auth module to the new API

Grok Build plans an approach for that objective. It breaks the work into a progress checklist. It then starts executing the checklist items one by one.

You are not locked out during the run. You can keep sharing additional instructions as it works. When the goal is finished, the panel flips to Complete. Every checklist item then shows as checked.

The Verification Step

The detail worth noting is verification. /goal does not stop at writing code. It continues until the task is completed and verified.

Verification, per xAI, can take three forms. The agent may review the code it produced. It may inspect webpages to confirm behavior. It may execute scripts to test the result.

This matters for autonomous runs. An agent that only edits files may report success before the change works. Building verification into the run means the agent tests its own output before it finishes.

Interactive Demo

<![CDATA[<![CDATA[<![CDATA[=items.length){ finish(); return; } var it=items[idx]; renderChecklist(); // log the step action with a verification verb where relevant var v = it.s; emit(stepVerb(idx)+" — "+v, idx<2 ? 'sys' : 'sys'); it.done=true; idx++; renderChecklist(); if(idx>=items.length){ finish(); } }, 1100); } function stepVerb(i){ var verbs=["Scanning files","Planning","Editing files","Reviewing output","Inspecting pages","Running scripts","Finalizing"]; return verbs[i]||"Working"; } function finish(){ if(timer){clearInterval(timer);timer=null;} running=false; setState(‘COMPLETE’); statusBox.classList.add(‘complete’); emit("Goal complete. All checklist items verified.", ‘ok’); renderChecklist(); runBtn.disabled=false; gi.disabled=false; cPause.disabled=true; cResume.disabled=true; cClear.disabled=false; resize(); } // controls cPause.onclick=function(){ if(!running) return; paused=true; setState(‘PAUSED’); emit("Work paused. The goal is kept.", ‘sys’); cPause.disabled=true; cResume.disabled=false; }; cResume.onclick=function(){ if(!running||!paused) return; paused=false; setState(‘RUNNING’); emit("Resuming from the last checklist item.", ‘sys’); cPause.disabled=false; cResume.disabled=true; }; cClear.onclick=function(){ if(timer){clearInterval(timer);timer=null;} running=false; paused=false; items=[]; idx=0; con.innerHTML=”; setState(‘IDLE’); statusBox.classList.remove(‘complete’); checks.innerHTML=’ <div class="empty">No active goal.<br />Type a goal above or pick an example, then run.</div> ‘; setProgress(); emit("Goal dropped. Ready for a new objective.", ‘sys’); runBtn.disabled=false; gi.disabled=false; cPause.disabled=true; cResume.disabled=true; cClear.disabled=true; gi.focus(); }; cStatus.onclick=function(){ var done=items.length?items.filter(function(i){return i.done;}).length:0; emit("/goal status — "+stateEl.textContent+" · "+done+"/"+items.length+" steps complete", ‘you’); statusBox.scrollIntoView({behavior:’smooth’,block:’nearest’}); }; runBtn.onclick=startGoal; gi.addEventListener(‘keydown’,function(e){ if(e.key===’Enter’){ startGoal(); }}); // auto-resize for WordPress srcdoc iframe (component height + ~40px) function resize(){ try{ var h = root.offsetHeight + 40; parent.postMessage({type:’mtp-goal-resize’, height:h}, ‘*’); }catch(e){} } var ro = window.ResizeObserver ? new ResizeObserver(resize) : null; if(ro) ro.observe(root); window.addEventListener(‘load’,resize); setInterval(resize, 1200); })(); </script> </body> </html> “>]]]]]]><![CDATA[><![CDATA[>]]]]><![CDATA[>]]>

Use Cases With Examples

Module migration is the main example. /goal Migrate the auth module to the new API covers a multi-file change. The task is long, mechanical, and testable.

Other practical handoffs fit the same shape:

Refactor a service, then run its test suite to confirm a green build.
Add an endpoint, then inspect the rendered page for runtime errors.
Upgrade a dependency, execute the build, and fix the breakages.
Port a config across files, then run a script to validate it.

Each task suits an autonomous goal better than a quick one-line edit. The payoff comes when the work spans many steps you would otherwise supervise.

Steering a Long-Running Goal

/goal adds commands to monitor and steer the run. You type them inside the Grok Build session:

/goal status     # see the live progress panel
/goal pause      # stop work, keep the goal
/goal resume     # pick back up
/goal clear      # drop the goal entirely

status surfaces the live progress panel. pause halts work but keeps the goal intact. resume continues from where it stopped. clear drops the goal entirely and starts fresh.

These controls are important for unattended runs. You can pause work or drop the goal at any point. That helps when an agent edits files and runs scripts on its own.

How `/goal` Compares

/goal sits among terminal coding agents that already run multi-step work. What it adds is an explicit, steerable goal object. The named lifecycle commands and the built-in verification step are the new parts.

Dimension	Grok Build `/goal`	Claude Code	OpenAI Codex CLI	Cursor Agent Mode
Handoff model	One-line goal object	Conversational + task list	Prompt with approval mode	Chat instruction in IDE
Progress view	Auto checklist + live panel	Internal to-do list	Step-by-step log	Inline edit stream
Steering controls	`status` / `pause` / `resume` / `clear`	Interrupt and reprompt	Approve / reject steps	Accept / reject edits
Verification	Runs until completed and verified	Runs tests when instructed	Runs tests when instructed	Runs tests when instructed
Where it runs	Terminal (TUI, headless, ACP)	Terminal	Terminal	IDE-integrated
Access	SuperGrok / X Premium Plus	Subscription or API	Subscription or API	Subscription

Key Takeaways

/goal runs long, autonomous tasks inside Grok Build’s terminal agent.
It plans an approach, builds a checklist, executes, and verifies until complete.
Verification can review code, inspect webpages, or execute scripts.
status, pause, resume, and clear steer the live run.
Access needs a SuperGrok or X Premium Plus subscription.

<![CDATA[<![CDATA[<![CDATA['; row.appendChild(b); row.appendChild(s); var t=document.createElement('p'); t.className="txt"; t.textContent="“"+d.t+'”'; var m=document.createElement('div'); m.className="meta"; var th=document.createElement('span'); th.className="theme"; th.textContent=d.theme; var a=document.createElement('a'); a.className="lnk"; a.href="#"; a.textContent="add source link"; a.onclick=function(e){e.preventDefault();}; m.appendChild(th); m.appendChild(a); c.appendChild(row); c.appendChild(t); c.appendChild(m); grid.appendChild(c); }); resize(); } Array.prototype.forEach.call(tabs.children,function(btn){ btn.onclick=function(){ Array.prototype.forEach.call(tabs.children,function(b){b.classList.remove('on');}); btn.classList.add('on'); render(btn.getAttribute('data-f')); }; }); render('all'); function resize(){ try{ parent.postMessage({type:'mtp-reactions-resize', height: root.offsetHeight+40}, '*'); }catch(e){} } var ro = window.ResizeObserver ? new ResizeObserver(resize) : null; if(ro) ro.observe(root); window.addEventListener('load',resize); setInterval(resize,1200); })(); </script> </body> </html> “>]]]]]]><![CDATA[><![CDATA[>]]]]><![CDATA[>]]>

Check out the Technical details. Also, feel free to follow us on Twitter and don’t forget to join our 150k+ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well.

Need to partner with us for promoting your GitHub Repo OR Hugging Face Page OR Product Release OR Webinar etc.? Connect with us

Meta Is ‘Pausing’ Employee Tracking Program After It Let The Whole Company See Sensitive Data

Alibaba’s AI video model rises to No. 2 in global rankings, as OpenAI’s Sora and ByteDance’s Seedance fall away

Michal Sutter is a data science professional with a Master of Science in Data Science from the University of Padova. With a solid foundation in statistical analysis, machine learning, and data engineering, Michal excels at transforming complex datasets into actionable insights.

Credit: Source link