Argus

Argus is a session-backed agent orchestrator. It's a long-running harness session (Claude Code, Codex, or OpenCode — whichever you have as your default) that reads a mission note you write, then spawns and manages coding sub-agents — each in its own git worktree — to execute the work in parallel.

Creating an Argus

1. Open the Creation Picker (Cmd+N).
2. Select Argus.
3. Give it a name and pick or create a Mission note.

The Mission note is a Scape note where you write your instructions — what repos to work on, what tasks to complete, constraints, priorities. Argus stays idle until the Mission note has content.

How it works

Argus runs on a pulse timer — its heartbeat, configurable from 1 minute to 4 hours. On each pulse it:

1. Reads the Mission note for instructions.
2. Evaluates the current state of its child sessions.
3. Spawns new child sessions as needed — each in a fresh git worktree.
4. Reports status and progress.

Children are real coding sessions with full capabilities. They can edit files, run tests, create PRs — everything a normal session can do.

Timed pulses only happen while the Argus is Watching. You can also put it to sleep or switch it off — see Modes.

Modes

An Argus is always in one of three modes. The mode decides what is allowed to reach it.

	Watching	Sleeping	Disabled
Timed pulses	Yes	No	No
Messages from children, other agents, Flight Plans, triggers, and calendar events	Delivered	Delivered — each one wakes it	Not delivered
Scheduled Events	Delivered	Delivered — each one wakes it	Not delivered
You typing in its session	Always	Always	Always
Session kept running (restarted if it exits)	Yes	Yes	No

Change the mode in any of three places:

• The status pill on the Argus card — each click moves one step: Watching → Sleeping → Disabled → Watching.
• Right-click the Argus card → Mode — pick any mode directly.
• The Heartbeat tile in the Mission note's header card — the same three-way switch.

Only you can change the mode. An Argus can read its own mode but can't switch itself.

Sleeping

A sleeping Argus stops pulsing but stays reachable. It does nothing until something arrives — a child reporting in, a message from another agent, a Flight Plan, a trigger, a calendar event, or one of its Scheduled Events — and then it's prompted to handle that and go back to idle. Use it when the work is waiting on something and you don't want a model turn spent on every heartbeat.

When you switch an Argus to Sleeping, it receives one [sleep] handoff message shortly afterwards, once it's idle. The handoff tells it there are no more timed pulses and asks it to:

1. Record where things stand in its log table.
2. Check what it already has scheduled.
3. Schedule an event for anything that needs attention later.
4. Tell you plainly, in its session, if what's needed is a decision from you.

The handoff is sent once. Cycling the pill round and back to Sleeping with nothing happening in between sends nothing. If the Argus has pulsed or received anything since its last handoff, it gets a fresh one the next time it enters Sleeping.

Disabled

Disabled is off. Nothing automated reaches a disabled Argus — no pulses, no child reports, no messages from other agents, no Flight Plan activity, no triggers, no calendar events, no Scheduled Events. Only you, typing in its session, do. The card's Reply button is unavailable, and Scape stops keeping its session alive.

What happens to things addressed to it:

• A new message is refused, and the sender is told the Argus is disabled. Nothing is stored.
• A child reporting to its disabled manager is asked to hold its update and try again later. That happens for its first three attempts; if the next one is still refused, it's told to stop retrying and raise it with its own human.
• A trigger fire or calendar event aimed at it is refused visibly — see Triggers and Calendar.
• Messages that were already queued when you disabled it are held, not dropped. The pill shows how many are waiting to be delivered — for example Disabled · 2 held — and they're delivered, oldest first, once the Argus is Watching or Sleeping again.

Scheduled Events

A Scheduled Event is a message set to reach an Argus at a future time. It's how a sleeping Argus gets timed attention without a heartbeat: when the event comes due, it's delivered like any other message, and that wakes the Argus.

Events can be set from two sides:

• By the Argus itself. It can schedule a message to its future self, list what it has scheduled, and cancel events it set. This is what the [sleep] handoff asks it to do.
• By you. The Scheduled Events group in the Mission note's header card lists every event for that Argus, with a form to add one — a number of minutes from now and the message — and a Cancel button on each event that hasn't fired.

When an event fires, the Argus receives it marked as a scheduled event, with who set it and when it was due. It wakes the Argus, not you — there's no notification. The Argus is instructed to contact you only if it needs you.

Good to know:

• Late, not dropped. If Scape was closed when an event came due, it's delivered when Scape is next open.
• It waits for the right moment. A due event waits while the Argus is Disabled and while your subscription isn't active — then it's delivered. If the Argus is mid-turn, what happens depends on the agent it runs on: some accept the event during the turn and handle it afterwards, others aren't sent it until they're idle.
• One-shot. An event fires once. For something recurring, use the project Calendar.
• An Argus can only cancel events it set. An event you set is yours to cancel. You can cancel any.
• You can't add events to a disabled Argus, and it can't schedule its own.

Limits: an event must be at least 1 minute and at most a year ahead, its message is at most 8 KB, and an Argus can have up to 20 unresolved events at a time. Events an Argus sets for itself must be at least 1 minute apart, so it can't use them to wake itself more often than the fastest heartbeat. Events you set aren't spaced.

Each event shows one of four states:

State	Meaning
Scheduled	Not due yet.
Due	Due, and waiting to be delivered. Can still be cancelled.
Delivering	The event has been written into the Argus's session — which, on some agents, can happen while it's still mid-turn. Can no longer be cancelled.
Failed	Scape couldn't confirm delivery after several attempts, so it may never have reached the Argus. Shown for 24 hours.

If your subscription lapses

Argus needs an active subscription. While it's inactive, automated delivery is paused for every Argus that is Watching or Sleeping — a lapse blocks wake-ups too, so a sleeping Argus isn't woken by a message it couldn't act on.

• The status pill reads Paused: subscription. Clicking it opens the license window.
• No pulses are sent and no sessions are restarted. Children that are already running are left alone.
• Messages already queued, and Scheduled Events that come due, are held and delivered once the subscription is active again.
• New messages are refused, and the sender is told the Argus is paused because the subscription isn't active. A child reporting to its manager is asked to hold and retry three times, then told to stop if its next attempt is still refused.
• Trigger fires and calendar events aimed at an Argus are refused.
• You can still type in the session yourself — that's never blocked.

Everything resumes on its own when the subscription is active again.

While Scape is re-checking your license

Scape re-checks your license periodically and when your Mac wakes, and it may also re-check at launch or after something was held back by the subscription (repeat checks are limited).

A re-check on its own changes nothing: if your subscription is already showing as active, everything carries on normally while it runs. It only matters when Scape's saved state says "not active" and a re-check is under way. For those few seconds Scape doesn't yet know whether "not active" is real or just out of date, so for a Watching or Sleeping Argus it holds new messages instead of refusing them:

• A message to an Argus by name, and a child's report to its manager, are queued. The sender is told the message is queued while the subscription is re-checked, and not to resend it.
• A trigger fire and a calendar event are accepted into the same queue and held. They aren't refused.
• If the check comes back active, the queued messages are delivered. If it comes back lapsed, they stay held until the subscription returns.
• A message sent straight to the Argus's session by ID has nothing durable to queue under, so that sender is asked to retry in a moment.

For a Watching or Sleeping Argus whose subscription is recorded as inactive, the pill stays Paused: subscription during the re-check — there's no separate state for it. A Disabled Argus stays Disabled and keeps refusing.

Child sessions

When Argus spawns a child, it:

• Creates a git worktree via create_worktree.
• Launches a coding session in that worktree via create_session.
• Seeds the child with full auto-approve for coding tools (edit, write, bash) so it's never blocked on permissions.

Limits

• Max children: Defaults to 8. Configurable (2, 4, 8, or 16) via right-click on the Argus card.
• Spawn depth: Children cannot spawn further children — depth is limited to 1.

Risky tools

By default, children are denied risky tools (playbooks, remote execution, external browsing). You can enable these per-Argus via right-click → Allow risky tools for new children.

Default child harness & account

The header card of the Mission note (the one with the avatar, Heartbeat, and Max children) also sets which harness and account new children spawn with when the manager doesn't pass one explicitly:

• Child harness — the default harness a child is spawned with. Works for all harnesses. The first option, Follow default (…), inherits the manager's own harness (its name is shown in the parentheses); the remaining options pin a specific harness (Claude Code, Codex, or opencode). Choosing Follow default is reversible — it clears the override back to inherit.
• Account — the default account profile children authenticate as. This header default currently applies to Claude Code only. Its first option, Default (project account), inherits the project's account at spawn; the rest are your detected Claude profiles, and a stored profile that's no longer on disk is shown as (missing?). For Codex and opencode, set the per-project account in the project-tree Profiles popover instead — the mission header doesn't configure their account defaults.

Monitoring

Status pill

The Argus card in the sidebar shows a status pill:

Status	Meaning
Watching (full dot)	Pulsing on its heartbeat and receiving messages.
Sleeping (half-filled dot)	No timed pulses; wakes when something messages it or a Scheduled Event fires.
Disabled (hollow dot)	Nothing automated reaches it. Reads Disabled · N held when messages are waiting to be delivered to it.
Paused: subscription	Your subscription isn't active — including while Scape is re-checking a subscription it has recorded as inactive. Shown for a Watching or Sleeping Argus; a Disabled one keeps showing Disabled. Click to open the license window.
No mission	Needs a Mission note assigned.

Click the pill to step to the next mode. Hover it for details — a sleeping Argus shows when its next Scheduled Event is due.

Log table

Argus automatically provisions a table and appends structured log entries on each pulse — timestamp, event kind, child info, repo, status, and summary. Open it via the database icon on the Argus card header.

Fleet view

Click the Argus card to open its backing session (the manager's terminal). Child sessions appear nested beneath the Argus card in the sidebar.

MCP tools

Argus uses a small set of capability-gated MCP tools:

Tool	Description
get_argus_status	The fleet view: the Argus's own state plus every child's live activity. Includes its mode (watching, sleeping, or disabled), its scheduled_events, and the current time (now, plus now_local and timezone) so it can schedule against the right clock. next_pulse_at is present only while Watching, and only once it has pulsed at least once.
set_argus_log_store	Binds a table as the Argus's log table.
schedule_argus_event	Schedule a message to itself. Takes a message, an optional title, and exactly one of in_minutes or at. Give at as a local time with no UTC offset (for example 2026-10-06T15:00:00) and Scape reads it in your time zone, with the right daylight-saving offset for that date.
list_argus_events	List its Scheduled Events with each one's state and who set it.
cancel_argus_event	Cancel an event it set, by event_id. Refused for an event you set, and for one whose delivery has already started.

These are gated by a per-Argus capability secret (SCAPE_ARGUS_CAP env var) that prevents other sessions from impersonating the Argus.

Known limits

• A message already written into the session can still land. If you disable an Argus, or the subscription lapses, in the instant between a message being written into its session and being submitted, that one message can still be submitted.
• No second handoff while it stays asleep. A sleeping Argus that's woken by a message and left in Sleeping doesn't get another [sleep] handoff. It gets a fresh one the next time you switch it into Sleeping.
• Typing in the session doesn't count as "received something" for the purpose of a fresh handoff. The card's Reply button does.
• A duplicate is possible. If Scape can't confirm a message arrived, it tries again a few times, so the Argus can see the same message twice.
• Copilot and Cursor managers don't queue. Where another Argus would have a message queued for it — while it's restarting, or during a license re-check — one running on Copilot or Cursor refuses it instead.
• Going back to an older version of Scape loses the new state. A sleeping Argus comes back Disabled, and pending Scheduled Events can be delivered early instead of at their due time.

Deleting an Argus

Right-click the Argus card → Delete Argus. A confirmation dialog lets you choose whether to close child sessions or keep them running independently. Its Scheduled Events are removed with it, and a message still waiting for it is refused — the sender is told the Argus no longer exists.