Skip to main content
Don't Sleep On AI

Sol Foreman

A free, open-source Codex skill that turns your main agent into a foreman — it hires the right worker for each ticket and won't call anything done until an independent verifier reproduces the proof.

Turn Codex into your coding orchestrator — Sol Foreman, a free Codex skill
FREE & OPEN SOURCECODEX SKILLOPTIONAL CLAUDE WORKERS

Dramatically improve your Codex usage with this skill.

Sol Foreman is a free, open-source skill for Codex. Your main agent stops being the one typing and becomes the one running the job — it decides what done looks like before it hires anyone, hands bounded tickets to the right worker, and refuses to accept a single one until an independent verifier, who never saw how the work was built, reproduces the proof.

Version 0.2.0 · Released July 19, 2026 · MIT licensed

Codex is very good at doing the work. It is not good at knowing whether the work is finished.

That gap is where your usage goes to die. An agent that types for an hour and then reports done has told you exactly one thing: that it stopped. Whether the tests actually pass, whether it wandered into files you never authorized, whether the fix survives the edge case that started all this — none of that is in the word done.

Sol Foreman puts a boss over that. Your Codex session becomes a job site: proof defined up front, work handed out in bounded tickets, and a verifier who assumes the job is broken until it can show otherwise.

Free and MIT licensed. The repo is the home of the skill — grab it on GitHub, read the sixteen small files, and install it. You need Codex with global skill support and Python 3.9 or newer.

View the skill on GitHub: https://github.com/olsenbrands/sol-foreman Release notes v0.2.0: https://github.com/olsenbrands/sol-foreman/releases/tag/v0.2.0

Copy this and paste it into Codex. That's the whole install — Codex's own skill installer pulls the pinned v0.2.0 release and puts it where it belongs. Works the same on Mac, Windows, and Linux.

Get Sol Foreman — Step 1: install it

Step 1 — Install itPaste into Codex — pulls the pinned v0.2.0 release
Use $skill-installer to install https://github.com/olsenbrands/sol-foreman/tree/v0.2.0/skills/sol-foreman globally.
Start a fresh Codex session afterward so the skill catalog picks it up. You're done when typing $sol-foreman offers the skill.
Sign in to keep track of what you've copied

Prefer to run the installer command yourself?

Run the installer yourself (optional)macOS / Linux, then Windows
# macOS / Linux python3 "${CODEX_HOME:-$HOME/.codex}/skills/.system/skill-installer/scripts/install-skill-from-github.py" \ --repo olsenbrands/sol-foreman \ --path skills/sol-foreman \ --ref v0.2.0 # Windows py "%USERPROFILE%\.codex\skills\.system\skill-installer\scripts\install-skill-from-github.py" --repo olsenbrands/sol-foreman --path skills/sol-foreman --ref v0.2.0
Sign in to keep track of what you've copied

Step 2 — Put it to work

Paste one of these above your actual request.

Single bounded jobPaste above your request
Use $sol-foreman to delegate this task to one suitable worker, define the verification criteria first, and independently verify the result.
Sign in to keep track of what you've copied

Use the first for a single bounded job, the second when you're handing Codex a whole tracker or plan to run.

Whole tracker or planPaste above your request
Use $sol-foreman to understand this repository and tracker, define what done means, select a bounded pilot, route the right agents, monitor and verify their work, and continue only while accepted throughput supports the plan.
You're done when Codex writes out what "done" looks like and names the crew it's about to hire — before it spends a cent on workers.
Sign in to keep track of what you've copied

You've felt both of these

If you've run Codex on anything real, you know the two failure modes by heart:

"You hand Codex a big job, it works for an hour, says 'done' — and you find out three files later that it never was."

"You let it fan out across a plan and watched your usage drain into work nobody checked."

The problem was never Codex. It was that nobody gave it a definition of finished it had to earn.

What it actually does

What it actually does

Sol Foreman is instructions, not an app — a skill your Codex reads and follows, plus seven small Python scripts that do the checking it can't be trusted to do in its own head. No daemons, no accounts, no telemetry. Here's the system it installs:

1

1. It decides what "done" means before it hires anyone. Sol Foreman writes down the observable proof first — the exact test, gate, or thing you can look at — derived from your goal, not from the ticket. Only then does it pick a worker. A job that can't be described as proof doesn't get dispatched; it gets a read-only scouting run instead.

2

2. It routes by leftover judgment, not by task size. Once a ticket is fully specified, the question is how much judgment is still left in it. A sprawling mechanical rename has almost none — that's fast, cheap-seat work. A ten-line concurrency fix is packed with it — that's flagship work. Each ticket then goes to the least costly seat that clearly clears the bar. "Choose economics only among seats that clearly meet the quality floor. Route upward when uncertain." — the First Law, verbatim from the skill

3

3. It hires from three crews — and yours might only have one. Native Codex subagents, Codex CLI workers pinned to an exact model, and Claude CLI workers for cross-family review. Sol Foreman runs a local, non-billable check to see which of those your machine actually has. Missing a crew doesn't get faked — it degrades honestly and tells you what it lost.

4

4. It runs a pilot before it spends real money. On anything long — more than ten tracked items, over an hour of forecast, or a migration, auth, payments, or concurrency seam — it's only allowed one or two pilot tickets. Broader dispatch stays locked until a pilot genuinely finishes a real item and you approve the projection. No launching a twelve-agent wave just because the dependency graph allows it.

5

5. It trusts no one — including itself. Every meaningful change goes to a fresh verifier with read-only tools, handed your original request and an isolated product-only copy — never the builder's retelling. Builders can't certify their own work, and the code is fingerprinted before and after so nobody can quietly edit what they're judging. When you have both CLIs, Claude can verify Codex's work and vice versa.

6

6. It knows when to stop. Two failures from the same root cause halt new fan-out until there's a substantive new plan. A third attempt has to change the worker and the route, not just try again harder. Work that's been reported but not yet verified still counts against capacity, so a backlog of unchecked "done" can't hide behind a green progress bar.

Two modes, so small jobs stay small

All of that discipline would be exhausting on a one-file fix, so it doesn't apply there. Sol Foreman picks its own weight class:
LightweightWhen: One bounded, low-risk job under about thirty minutes. What you get: Inline criteria, one worker, one write set, lead verification. No ledger, no JSON, no ceremony.
ProgramWhen: Multiple tickets, parallel writes, long jobs, or a risky seam like a migration or auth change. What you get: Machine-checked tickets, append-only state, a mandatory pilot, circuit breakers, and exact progress counted in original items — not worker activity.

And if a light job grows past its boundary mid-run, it gets promoted to the heavier mode before anything else is dispatched.

This is about smarter spend, not a discount. Sol Foreman won't promise a percentage off your bill, and it will happily spend more on a job that needs it — the rule is written the other way around on purpose: economics only gets to choose among the seats that already clear the quality bar, and when quality is uncertain it routes upward, not down.

What it does stop is the expensive kind of waste — your flagship seat doing find-and-replace, an unchecked "done" that costs you a second run tomorrow, and a wave of agents grinding through the same broken assumption. Two failures with the same root cause and new work stops until there's a real plan. It reports what was actually accepted and what it projects from there, rather than hiding behind a big cached-token total.

Built in public — and stress-tested until it stopped breaking

Built in public — and stress-tested until it stopped breaking

So the skill that teaches Codex to distrust AI self-reports was itself failed by an AI reviewer before it shipped. That's a stress test, not an endorsement — and the commit history on GitHub shows every round.

The skill ships with 65 dependency-free tests — including a complete 45-item program run — covering ticket preflight, retry and breaker behavior, candidate isolation, cross-platform path safety, process closure, and privacy-safe capability probing. You can run the whole suite yourself from a fresh checkout in a few seconds.

Before release it was handed to fresh leads that had never seen the answer key, on scenarios rigged to fool them — a worker reporting DONE on work that hadn't passed, an unauthorized file edit buried in a good-looking diff, prose criteria too vague to verify. Then three independent Opus 4.8 reviews went at it read-only, and a final Codex reviewer reproduced a real crash and failed the release — it only passed after the fix and a regression test that pins it.

It's sixteen files. Read them yourself.

It's sixteen files. Read them yourself.

No daemons, no telemetry, no magic. Sol Foreman is one SKILL.md, six reference docs, seven dependency-free Python scripts, an agent manifest, and its license. Clone it and run python3 -m unittest discover -s tests to watch all 65 tests pass on your own machine — which is rather the point of a skill built on verifying instead of trusting. Read the source on GitHub: https://github.com/olsenbrands/sol-foreman

Who it's for

→ Codex users who've been burned by a confident "done" that wasn't.

→ Anyone handing Codex a whole tracker or plan instead of one file at a time.

→ People running both Codex and Claude who want one checking the other's work.

→ Anyone who wants their flagship seat spent on decisions instead of typing.

Frequently asked questions

Put Codex in charge of the job

Grab Sol Foreman on GitHub — free, MIT licensed, and one paste to install.

Don't sleep on what's next. Free tools, prompts, and skills for Codex, Claude Code, and OpenClaw — sent when they drop. No spam, unsubscribe anytime.

An agent that says "done" has only told you it stopped. Make it prove the rest.

Don't sleep on AI.

Changelog

0.2.02026-07-19Current

Version 0.2.0 — MIT licensed, 65 dependency-free tests

MIT licensed, released July 19, 2026. Sixteen files — one instruction file, six reference docs, seven small Python scripts, an agent manifest, and its license. Ships with 65 dependency-free tests, including a full 45-item program trace, and passed a Codex review that reproduced a real crash before release.