Goals

Normally the agent stops when it thinks it has answered you. A goal changes that: you state a condition, and Syntic Code keeps taking turns until the condition is actually met.

/goal every test in packages/api passes and the linter reports no errors

After each turn, a small model reads the conversation and decides whether the condition holds. If not, the agent gets another turn with a note saying what is still missing. It stops when the goal is met, when it has used its turn budget, or when you clear it.

Ways to keep a session working

Tool	Keeps going	Stops when
`/goal`	Turn after turn on one task	The condition is met, 20 turns pass, or you clear it.
`/loop`	Re-runs the same prompt every few minutes while you are idle	You stop it or close the session.
`/schedule`	Runs prompts on a timetable whenever a session is open in the project	You pause or delete it.
A `Stop` hook	Your own script decides after every turn	Your script lets it stop (or after 8 blocks in a row).

Use a goal when you know what “done” looks like but not how many attempts it will take.

Set a goal

/goal the build succeeds on the new toolchain and the smoke tests pass

Setting a goal starts work on it right away. If a turn is already running, the first check happens when that turn ends. Setting a new goal replaces the old one.

The agent receives the condition as its task: work toward it and keep going until it is met. You can keep typing while a goal is active; your messages join the conversation and the next check takes them into account.

Write a condition that can be checked

The checker only sees the conversation. It judges from what was done and shown, not from what the agent says it intends. Good conditions point at evidence that will appear in the transcript:

Weak	Strong
”The code is good."	"`cargo clippy` reports no warnings and `cargo test` passes."
"Fix the flaky test."	"`test_upload_resume` passes 20 runs in a row."
"Make the page faster."	"The Lighthouse performance score for /pricing is 90 or more, measured and shown."
"Finish the migration."	"No file under src/ imports from `legacy/`, confirmed with grep, and the build passes.”

Name the command that proves it. The agent will run it, and the output becomes the evidence the checker reads.

Check on it

/goal on its own shows the current goal, how many turns it has taken and how long it has run:

Goal: every test in packages/api passes and the linter reports no errors
3 turn(s) so far, 214s. /goal clear stops it.

After each check you see one of these lines:

Message	Meaning
`Goal not met yet (<what is missing>); continuing.`	Another turn starts with that note.
`Goal met after N turn(s): <reason>`	Done. The goal is cleared.
`Goal stopped after 20 turns without being met.`	The turn budget ran out. The goal is cleared.
`Goal stopped: <reason>.`	The check could not be made (no answer, or an unreadable one). The goal is cleared.

Clear a goal

/goal clear

/goal stop and /goal off do the same. The current turn finishes, and no further checks or turns follow. Press Esc as well if you want to interrupt the running turn.

Goals belong to the running session. They are not saved with it, so a resumed session starts without a goal; set it again if you still need it.

Run a goal in a script

A -p prompt that is a /goal line works the same way:

syntic -p "/goal npm run build succeeds and npm test passes" \
  --permission-mode acceptEdits --allowed-tools "Bash(npm run build),Bash(npm test:*)"

The run works on the goal, checks after each round, and continues with what is missing, up to the same 20-turn limit. Give the run the permissions it needs up front: nobody is there to answer a prompt (Scripting and CI).

How the check works

The check runs on the session’s small helper model, not the main model, so it is quick and cheap. The smallModel setting picks which one (Models).
It sees the goal and the most recent part of the conversation (up to about 12,000 characters).
It answers with a verdict and one short reason. When the condition is not met, the reason says what is missing, and that becomes the agent’s next instruction.
Each check adds a little cost on the small model. Each extra turn costs like any other turn on the main model.

The checker trusts the transcript. If the agent claims tests pass without running them, a strict condition (“passes, with the output shown”) makes the checker ask for proof.

Troubleshooting

Problem	What to do
The goal is declared met too early	Make the condition point at shown evidence: name the command and the expected result.
It keeps going in circles	Clear the goal, look at what is blocking, and give the agent a hint or a smaller goal.
It stops with “the check’s answer could not be read”	A one-off failure of the checker. Set the goal again.
It stops at 20 turns	Split the work into smaller goals, or check whether the condition can be met at all.
Turns stop to ask for permission	Allow the commands the goal needs (Permission rules), or use a permission mode that fits the job.

Loops and schedules Channels