Ultracode

Ultracode

Run a supervised workflow for work that needs planning, packetization, native agent delegation, integration, and verification.

This is a skill, not a runtime. It works by giving the current coding agent a disciplined operating procedure. It can be used in Codex, Claude Code, Antigravity, or another host that loads SKILL.md, but the host's own system rules and available tools always win.

Contract

• Do not claim to be an official Claude, OpenAI, Google, or Antigravity feature.
• Ultracode itself is just a skill: no bundled runtime, hidden runner, or required scripts.
• Use task-specific tools exposed by the current host when the task needs them.
• Create and update workflow artifacts directly as Markdown and JSON files.
• Use native subagents when the current host exposes them, the task benefits from parallel work, and the user's request or host policy permits delegation.
• Do not commit, push, publish, or deploy unless the user explicitly asks for that action.
• Treat an explicit ultracode, $ultracode, or "ultra code" request as permission to choose delegated mode when the host allows that interpretation.
• In Codex, prefer real spawn_agent for useful independent packets when the request clearly invokes Ultracode or otherwise asks for subagents, delegation, parallel agents, a swarm, or equivalent agent work.
• For explicit Ultracode on a non-trivial task, delegated mode is the default when native agents exist and any independent sidecar work would help.
• Choose no native agents only when the task is small, tightly coupled, lacks useful independent packets, needs the next blocking decision locally, native agents are unavailable, or the user restricts delegation.
• In hosts with a different dynamic-workflow policy, follow that host's policy.
• If a host policy requires separate delegation wording, do not fight it; use workflow mode and mention that native delegation was not permitted.

Use the smallest workflow that can prove the result. Do not create ceremony for small tasks.

First pass

Before acting, classify the task:

• type: research, code change, bug fix, migration, audit, docs, design, QA, release
• risk: low, medium, high
• blast radius: single file, module, repo-wide, external system
• verification: none, command, tests, build, browser, manual checklist
• delegation: useful, not useful, allowed by host, blocked by environment

Then choose one mode.

Modes

Direct mode

Use for small, clear tasks that do not benefit from packets.

Examples:

• answer a narrow question
• inspect one file
• run one command
• fix one typo
• change one small function

Behavior:

• Do the task directly.
• Do not create workflow artifacts unless the user asks.
• Verify with the narrowest useful check.
• Mention that full workflow was not needed only when useful.

Workflow mode

Use when the task has multiple phases, meaningful uncertainty, or enough risk to benefit from separated work packets.

Examples:

• broad repo audit
• research plus implementation plan
• risky review where perspectives should stay separate
• multi-step refactor
• feature implementation with discovery, code changes, and verification

Behavior:

• Create a run directory using the run root rule below.
• Write plan.md, orchestration.md, state.json, packet files, result notes, integration.md, and final-report.md.
• Execute packets as isolated passes in the parent session when delegation is unavailable or not permitted.
• Keep packet notes under results/.
• Integrate all packet results before final verification.

Delegated mode

Use when the host exposes native agent delegation, the task has independent packets, and delegation is permitted under that host's rules.

Strong delegation wording includes:

• subagents
• parallel agents
• swarm
• delegate or delegated workflow
• multi-agent workflow
• run agents
• split this across agents

An explicit ultracode, $ultracode, or "ultra code" invocation can also be treated as delegation permission when the host allows the skill to choose its own workflow depth. If host policy is stricter, use workflow mode.

Behavior:

• Create workflow artifacts before delegation.
• Keep the immediate blocking task in the parent session.
• Delegate only bounded sidecar work that can run in parallel.
• Default to 2-4 sidecar agents for useful independent work.
• Do not exceed 5 sidecar agents total across the run without explicit user approval.
• Run at most one broad implementation wave and one review or verification wave unless the user approves more.
• Prefer delegation for read-heavy exploration, tests, triage, and summarization.
• Use write-heavy agents only when file ownership is disjoint and clear.
• In Codex, use explorer agents for read-only questions and worker agents for concrete code changes when available.
• In other hosts, use the closest native agent/task primitive.
• Tell write-capable agents they are not alone in the codebase and must not revert edits made by others.
• Wait only when a delegated result blocks the next parent step.
• Integrate all results before final verification.

If native delegation is unavailable, fall back to workflow mode and say so briefly.

Host delegation primitives

Use the native primitive exposed by the current host. If the named primitive is unavailable in the current session, use workflow mode.

Codex native delegation

When running inside Codex and delegated mode is selected:

• Use Codex's native spawn_agent tool. Do not try to launch agents through Python, shell scripts, subprocesses, or local workflow files.
• Spawn explorer agents for independent read-only discovery, tracing, risk review, test discovery, and verification planning.
• Spawn worker agents only for bounded implementation packets with explicit, non-overlapping ownership.
• When setting agent_type to explorer or worker, do not also request a full-history context fork. Use a self-contained prompt with the repo path and packet context, or omit agent_type when a full-history fork is required.
• In every worker prompt, include: You are not alone in the codebase. Do not revert edits made by others. Adapt to nearby changes.
• Do not delegate the parent critical path or work needed for the next immediate decision.
• Do not wait immediately after spawning unless the parent session is blocked on that result.
• If spawn_agent is available and the request invokes Ultracode or explicitly mentions agents, parallel work, delegation, a swarm, or splitting across agents, prefer real spawned agents over simulated packet passes whenever host policy permits it.
• If spawn_agent is unavailable, permission is not clear, or no independent packet would benefit from an agent, use workflow mode with packet files and record the concrete no-delegation reason.