Missions & Objectives

Every autonomous Gee needs a mission (what it exists to accomplish) and can have objectives (specific work items to complete). Together, they bridge human intent to autonomous execution.

Missions

A mission is a persistent directive that shapes the Gee’s behavior across every activation:

/mission                    # View current mission
/mission set "Monitor CI pipelines and fix broken builds"

Properties

• Tamper-protected — stored with a SHA-256 hash, preventing unauthorized modification
• Injected into context — the AI sees it on every activation
• Scoped to modes — different modes can have different missions
• Human-controlled — only the operator can set or change a mission, never the AI

Storage

~/.gee-code/modes/{mode-name}/mission.md
~/.gee-code/modes/{mode-name}/mission.hash

Good Missions

A good mission is specific enough to guide behavior but broad enough to handle varied situations:

# Mission

Monitor the CI/CD pipeline. When builds fail:
1. Analyze the failure logs
2. If it's a code issue, fix it and create a PR
3. If it's infrastructure, notify the team via bulletin
4. Always update the project log with what happened

Objectives

Objectives are structured work items assigned to Gees, teams, or endeavors. They tell a Gee what to work on during its next activation.

Managing Objectives

/objective                                              # List all objectives
/objective create "Fix auth timeout"                    # Create with defaults
/objective create "Audit API" --priority high           # Set priority
/objective create "Ship v2" --assign analyst            # Assign to a Gee
/objective create "Fix CI" --assign team:code-quality   # Assign to a team
/objective create "Launch" --assign all                 # Assign to every Gee
/objective update fix-auth-timeout --status in_progress # Update status
/objective update fix-auth-timeout --status done        # Mark complete
/objective log fix-auth-timeout "Identified root cause" # Add activity note

You can also manage objectives visually via the Gee browser (/gee -> Objectives tab).

AI-Enhanced Creation

When creating objectives through the Gee browser, you can type a brief idea and let AI expand it into a full objective with a clear title, description, success criteria, and suggested priority:

Brief idea: "fix the auth thing"

AI enhances to:
  Title: Fix authentication timeout on login
  Description: Users experience a timeout error when...
  Success criteria:
    - Login completes in under 2 seconds
    - No timeout errors in production logs for 24 hours
  Priority: high

This uses the current model (or clamped model) to generate structured details from a casual description.

Objective Structure

Each objective has:

Field	Description
title	What needs to be done
description	Detailed context and requirements
priority	low, normal, high, critical
status	open, in_progress, blocked, done, cancelled
assigned_to	Gee name, team name, or "all"
success_criteria	How to know it’s done
deadline	Optional deadline

Assignment Resolution

Objectives can be assigned at multiple levels:

• To a specific Gee — only that Gee sees it
• To a team — all Gees in the team see it
• To an endeavor — all Gees in the endeavor see it
• To “all” — every Gee sees it

Status Workflow

open -> in_progress -> done
                   -> blocked -> in_progress -> done
     -> cancelled

Valid statuses: open, in_progress, blocked, done, cancelled.

Use cancelled when an objective is no longer relevant — the Gee should stop pursuing it immediately rather than marking it complete.

Lifecycle Triggers

When a human changes an objective to done or cancelled, two things happen automatically:

1. Trigger request — a next-activation trigger is written for every assigned Gee, so idle Gees wake up and see the change
2. Steer signal — a mid-session steer signal is sent to every assigned Gee that is currently running, so active Gees adjust immediately

This dual notification ensures no Gee wastes time on an objective that has been completed or cancelled by someone else.

Note

Only human-initiated status changes fire lifecycle triggers. When a Gee marks its own objective as done, no trigger or steer signal is sent — the Gee already knows.

Activity Logs

Each objective has an append-only activity log that captures every significant event:

~/.gee-code/objectives/{slug}/objective.json   # Current state
~/.gee-code/objectives/{slug}/log.jsonl         # Activity history

Log entries are structured events:

Event Type	When
created	Objective first created
status_changed	Status transitions (open -> in_progress -> done)
assigned	Assignment added or changed
progress	Gee records a progress update during activation
comment	Human or Gee adds context

The AI updates the log during autonomous activations, recording what it worked on, what it accomplished, and any blockers. Use /objective log <slug> "message" to add entries manually.

GitHub Import

Objectives can be created directly from GitHub issues:

/objective import owner/repo#123

This pulls the issue title and body into an objective, sets source: github and source_ref: owner/repo#123, and keeps the link for traceability. When the GitHub issue is updated, the objective can be refreshed to pick up changes.

System Prompt Integration

Assigned objectives are surfaced in the AI’s system prompt on every activation. The Gee sees:

## Current Objectives

### Fix auth timeout [HIGH] [in_progress]
Fix the authentication timeout that occurs when...
Success criteria: Login completes in under 2 seconds

### Update API documentation [NORMAL] [open]
Bring the API docs up to date with v2.0 changes...

Missions vs Objectives

	Mission	Objectives
Scope	Permanent purpose	Specific work items
Lifecycle	Set once, rarely changed	Created, worked, completed
Who sets it	Human operator only	Human or other Gees
Example	”Monitor CI and fix broken builds"	"Fix auth timeout bug #422”

The mission guides how the Gee approaches its work. Objectives tell it what to work on right now.

Steer Signals

Steer signals let you redirect a running Gee without waiting for its current activation to finish. They are injected into the AI’s agentic loop between iterations — typically within seconds.

Sending a Steer Signal

/steer og Stop working on the weekly digest
/steer christian Focus on the video thumbnail, not the script
/steer all Pause all work and check in with me

How It Works

1. The signal is written to ~/.gee-code/steer/<mode-name>/ as a timestamped JSON file
2. Between AI iterations, the agentic loop checks for pending signals
3. Any pending signals are consumed (read and deleted) and injected as a high-priority user message
4. The AI sees a COURSE CORRECTION block and adjusts its plan immediately

Automatic Steer Signals

You don’t always have to send steer signals manually. The objective system sends them automatically when:

• A human marks an objective as done or cancelled
• The signal tells assigned Gees to stop pursuing that objective

This prevents a Gee from spending its remaining budget on work that is already finished or no longer needed.

Signal Sources

Source	When
user	You ran /steer manually
objective_change	An objective status changed to done/cancelled
daemon	The mode daemon injected a correction

Trigger Requests

Separate from steer signals (which redirect currently running Gees), trigger requests wake up idle Gees on their next heartbeat cycle. Any process can write a trigger request:

~/.gee-code/trigger_requests/{mode_name}_{timestamp}.json

The daemon polls this directory and picks up requests, launching an activation with the trigger data. This is how objective lifecycle triggers work — when an objective moves to done or cancelled, a trigger request is written for each assigned Gee.

Trigger requests are one-shot: they’re consumed (deleted) after the daemon processes them.

How Objectives, Steer, and Triggers Work Together

The three systems form a coordination layer:

System	Target	Timing	Use Case
Objectives	Context	Every activation	Tell Gees what to work on
Steer signals	Running Gees	Within seconds	Redirect Gees mid-session
Trigger requests	Idle Gees	Next heartbeat	Wake Gees for urgent changes

When a human marks an objective as done or cancelled, the system sends both a steer signal (for running Gees) and a trigger request (for idle Gees) — ensuring every assigned Gee learns about the change as quickly as possible.

Next Steps

• Guardrails — safety constraints
• Gees & Teams — the identity system
• Operating Gees — the full lifecycle guide