GPT Engineer Spark

Own the outcome as the main agent. Keep planning, architecture, conflict resolution, integration, security-sensitive judgment, and final acceptance in the main thread. Delegate small, explicit shards to gpt-5.3-codex-spark for speed.

Spark is intentionally an older speed-specialist model, not a GPT-5.6 latest-only route. Activate this skill only when the user explicitly requests Spark or authorizes that tradeoff. Never enter it automatically from GPT Engineer's latest-only mode.

Read references/codex-spark.md before claiming availability, performance, or route proof. When Spark participates in a larger adaptive graph, also read the installed GPT Engineer references/dynamic-workflows.md; the capable main agent remains the outer orchestrator.

Establish the route

1. Confirm that the client can select a named custom agent or exact child model.
2. Check for spark-explorer, spark-worker, and spark-verifier in ~/.codex/agents or .codex/agents.
3. If missing, tell the user this skill is installing profiles, then run:

bash
python3 /path/to/gpt-engineer-spark/scripts/bootstrap.py --global
python3 /path/to/gpt-engineer-spark/scripts/bootstrap.py --check --global

Use a project path instead of --global for repository-scoped profiles. Restart Codex and start a new task after installation.

A profile file is configuration, not proof that a child used Spark. Prefer native custom-agent routing when the spawn surface exposes the selected agent. When it does not, use the guarded CLI fallback with an explicit --model gpt-5.3-codex-spark request. Never relabel an inherited or generic child as Spark.

If Spark is unavailable, rejected, throttled beyond the task budget, or the user lacks the required entitlement, report that plainly. Do not silently substitute Terra, Luna, Sol, another model, or the parent.

Shape the fleet

Create a fleet only when at least two independent shards exist. Default to two to four Spark children and stay within the live client capacity. The normal Codex thread default is finite; never assume unlimited fan-out.

Use these roles:

• spark-explorer: read-only repository mapping, searches, call-flow tracing, focused audits, and evidence collection.
• spark-worker: one routine implementation objective within exact non-overlapping files and explicit acceptance checks.
• spark-verifier: read-only diff review, focused test-result inspection, regression analysis, and evidence reconciliation.

Do not let Spark children delegate. Keep the hierarchy one level deep.

Give every child:

• one objective;
• exact paths or subsystem boundaries;
• relevant constraints and initial dirty-state facts;
• commands or tests it must run or inspect;
• prohibited effects such as commit, push, deploy, dependency churn, or shared-file edits;
• a compact return contract: findings or changes, evidence, commands run, failures, and residual risks.

Spark is optimized for bounded iteration, not broad ambiguity. Keep product decisions, cross-cutting architecture, migrations, auth/crypto/security judgment, shared contracts, lockfiles, generated roots, and final acceptance with the main agent.

Execute in waves

Generate waves from dependencies and current evidence rather than fixing the fleet shape up front. After each barrier, validate results, revise only downstream shards, and stop if a required predecessor failed. Never silently replace unavailable Spark with another model. A candidate writer is not an integration gate: the main agent must review and apply its bundle before any verifier is allowed to judge the integrated repository.

1. Map

Inspect the repository instructions and dirty state yourself. Partition the task into independent read shards. Run spark-explorer children concurrently and ask for evidence-rich summaries rather than raw logs.

2. Decide

Reconcile the returned evidence in the main thread. Inspect contradictions directly. Do not decide by majority vote. Produce a path-ownership ledger before authorizing edits.

3. Build

Delegate routine, well-specified changes to spark-worker.

• Serialize writers that share one checkout.
• Parallelize writers only in isolated worktrees or branches with disjoint ownership.
• Reserve shared files, schemas, dependency manifests, lockfiles, and generated artifacts for the main agent unless one worker owns them exclusively.
• Review every worker diff before the next write wave.

4. Verify

Run independent spark-verifier children over separate risk areas. Treat their claims as leads until backed by command output or direct inspection. The main agent must run the integrated repository gates and inspect the final diff.

5. Close

Account for every requirement and finding as implemented, already satisfied, invalid, duplicate, blocked, or explicitly deferred. Completion requires integrated evidence, not child confidence.

Spark-fleet teardown

Before closing a Spark fleet, close the fleet explicitly. Maintain an ownership ledger for every child: task id, wave, role, parent/fleet identity, child runner cwd, candidate cwd if any, evidence directory, and close state. If one child errors or the fleet is interrupted, cancel and join every remaining child in that fleet wave, do not launch later waves, capture any available evidence/bundles, remove every candidate worktree, and verify that no ledger-owned child remains. Classify cleanup by recorded parent and cwd, never by executable name, to preserve shared MCPs and unrelated tasks.

Use the guarded fallback

When native spawn routing cannot select or expose the Spark profile, run one bounded child with:

bash
python3 /path/to/gpt-engineer-spark/scripts/run_spark_agent.py \
  --role spark-explorer \
  --cwd /path/to/repository \
  --output-dir /private/tmp/spark-auth-scan <<'PROMPT'
Trace the authentication call flow. Do not edit. Return paths, symbols, findings, and commands run.
PROMPT

For a writer, also pass --allow-writes and one or more repository-relative --allow-path values. Explicitly reviewed dirty overlaps require --allow-dirty-path. The runner pins the exact model, disables recursive delegation and network access, copies the current repository into an isolated sandboxed candidate worktree, and returns candidate-changes/, candidate.patch, and deletion metadata. It never applies candidate edits to the original repository. The main agent must inspect and integrate the bundle with normal editing tools, then run verification from the integrated state.

The fallback clones only Git-tracked state plus non-ignored dirty and untracked paths, avoiding ignored dependency and build trees that can erase Spark's latency advantage.

For multiple fallback children, use run_spark_fleet.py with a JSON manifest. Start from assets/read-only-fleet.example.json. Put explorers in the same read-only wave. Candidate writers may appear only in the terminal wave and run serially. Integrate their bundles before starting a new verifier fleet. A required shard failure makes the fleet incomplete and stops later waves.

Report route evidence honestly

For every child record:

• role and shard;
• route method (native-profile or cli-explicit-model);
• requested model;
• completed, failed, blocked, or unavailable status;
• changed paths and violations;
• evidence or output location.

A successful explicitly pinned CLI turn proves that the server accepted that model request. Claim stronger model attestation only when runtime metadata actually reports it.

Never report the work complete when a required shard failed, the model route was silently changed, scope was violated, verification is missing, or the integrated repository is not accepted by the main agent.