On July 25, 2026, OpenAI harness engineer Alex Kotliarskyi posted a two-step recipe that racked up ~600K views in a day:
How to graph-max with Codex and 5.6 Sol:
- Draw a graph (literally in any tool, even on paper)
- Send it to Codex and say “write a code mode script that implements this workflow, run it with your inputs”
There’s no step 3, it just works.
Peter Steinberger quote-tweeted: am I a graph engineer now — the same account that kicked off the July 18 graph-engineering wave with “loops or graphs yet?” The joke landed because the skill finally has a mechanical entry point, not only a vocabulary fight with loops.
This explainx.ai guide is the practical companion: the recipe, the resident/ephemeral sketch language, copy-paste prompts, and when “no step 3” is a lie.
TL;DR — What People Are Asking
| Question | Answer |
|---|---|
| Recipe? | Draw graph → Codex + Sol implements + runs |
| Model pair? | Codex + GPT-5.6 Sol (as posted) |
| Tools to draw? | Paper, Excalidraw, anything |
| Step 3? | Kotliarskyi says none — verify anyway |
| New meme? | “Am I a graph engineer now?” |
| Node types? | Resident vs ephemeral workers |
| Hub post? | Graph engineering orgs guide |
| Steal? | Sketch → code-mode → run → imagediff/tests |
The Sketch That Made the Meme Concrete
The diagram circulating with the thread is a classic work graph with a quality loop:
Legend
| Style | Meaning |
|---|---|
| Hatched / filled box | Resident agent — long-lived role, keeps context |
| Outline box | Ephemeral worker — spun for one step |
| Diamond | Conditional (Pass?) |
| Circle | Terminal IO (Task, Send to user) |
Trace the edges
- Task → ephemeral Planner
- Planner → resident Worker
- Worker fan-out to Reviewer 1 (resident) + Reviewer 2…N (ephemeral)
- All reviewers → ephemeral Synthesise
- Pass? — no loops back to Worker with feedback; yes → Turn into haiku → Send to user
- Side path: Planner + Pass? results → ephemeral Plan Reviewer → plan feedback also lands at Send to user
That last path is the tell: graphs are not only “do the work,” they can emit meta commentary (how the plan performed) alongside the deliverable. Loops rarely surface that without you bolting it on.
Same idea as org graph vs work graph in our hub post: Worker/Reviewer 1 look like org roles; Planner/Synthesise/haiku look like work-graph tasks.
Do the Two Steps Literally
Step 1 — Draw
Use whatever is fastest:
- Phone photo of a whiteboard
- Excalidraw / FigJam export
- ASCII in a markdown file
- The webp above as a reference pattern
Label edges (feedback, results, 1…N). Mark which nodes are resident vs ephemeral — Codex cannot infer longevity from vibes alone.
Step 2 — Prompt Codex (template)
Implement this agent workflow as a code-mode script and run it.
Inputs:
- task: "<paste user task>"
- model routing: use GPT-5.6 Sol for Worker and Reviewer 1;
cheaper/faster model OK for ephemeral Reviewer 2..N and Turn into haiku
Graph (see attached image / description):
- Task → Planner (ephemeral) → Worker (resident)
- Worker fans out to Reviewer 1 (resident), Reviewer 2..N (ephemeral)
- Reviewers → Synthesise (ephemeral) → Pass?
- Pass? no → feedback to Worker; yes → Turn into haiku → Send to user
- Planner + Pass? results → Plan Reviewer (ephemeral) → plan feedback → Send to user
Requirements:
- Explicit data contracts between nodes (JSON schemas)
- Max 3 Pass? retries then fail loud
- Log each edge with timestamps and token counts
- Run once end-to-end with the inputs above and print the user message + plan feedback
Kotliarskyi’s claim is that Sol-class codegen closes the sketch→runtime gap that used to need a human middleware paste between agents — the same pain Elwynn Chen’s multi-agent UI thread called out.
Step 3 (the one they said doesn’t exist)
Still do it:
- Re-run with a second input — does the graph hold?
- Break a reviewer on purpose — does Pass? feedback fire?
- Check token burn on fan-out N (parallelism is not free — Superlinear’s loops/graphs episode is the mental model Christine Yip pointed people at).
- Decide what becomes a durable runtime (LangGraph-class) vs a disposable code-mode script.
“No step 3” is great marketing for getting unstuck. Production still has a step 3.
Why This Hit Now
- Frontier codegen (Sol + Codex code mode) can implement branching workflows without you hand-writing the orchestration glue.
- Shared vocabulary — resident/ephemeral, Pass?, fan-out — travels in a single PNG.
- Steinberger meme surface — the July 18 graph engineering discourse needed a how, not another what.
- Loop fatigue — people who only
/loopone agent hit walls on review fan-out and plan critique; graphs name those walls.
Community replies already ship toy frameworks (athena-graphs, visual graph editors). Treat them as sandboxes; the durable skill is drawing contracts, not collecting logos.
Graph-Max vs Loop Engineering vs Prompting
| Layer | You design | Failure mode |
|---|---|---|
| Prompt | One response | No retry structure |
| Loop | One agent cycle | Can’t parallelize domains cleanly |
| Graph-max sketch→code | Nodes + edges + run | Sketch lies; codegen invents edges |
| Durable graph runtime | Same + persistence/observability | Over-structure simple tasks |
Rule of thumb from the hub: loop when one agent owns the task; graph when domains, parallelism, or long-lived roles appear. The Codex recipe collapses “I can’t wire LangGraph today” into “I can run the sketch tonight.”
Common Failure Modes
- Underspecified diamonds — Pass? without a rubric → infinite feedback or always-yes.
- Fake resident agents — you mark Worker resident but wipe context each turn.
- Unbounded N — Reviewer N fans out until the bill looks like a Series A. Cap N.
- Haiku cosplay — cute terminal nodes that hide missing Plan Reviewer signal.
- Skipping measurement — Claude of Duty’s lesson applies: if you can’t gate outputs, you’re graph-LARPing (imagediff mindset).
Copy-Paste Mini Graphs to Try Tonight
Code review
PR → Diff Agent (ephem) → Reviewer Security (resident) + Reviewer Style (ephem)
→ Synthesise → Pass? → merge comment / feedback to Diff Agent
Docs
Ticket → Researcher (resident) → Drafter (ephem) → Fact Checker (ephem)
→ Pass? → Publish / feedback
Support
Ticket → Triage (ephem) → Specialist A|B (resident pool) → Reply Draft
→ Policy Pass? → Send / escalate
Draw it. Attach the photo. Run the template prompt. Then decide if any node deserves a real harness.
What “Code Mode” Is Doing Here
Kotliarskyi’s phrasing assumes Codex can both author the orchestration script and execute it against your inputs in one session. That collapses three jobs humans used to do manually:
- Translate boxes into function calls / agent configs
- Wire retries and fan-out
- Actually press run and paste outputs between chat tabs
When that works, you feel like a graph engineer because the artifact is a graph — not because you memorized a framework. When it fails, the failure is usually in the sketch (missing Pass? rubric) or in unbounded parallelism, not in “Sol can’t code.”
If your team still argues loops vs graphs in Slack, paste the Kotliarskyi two-liner and ship a sketch the same afternoon. Vocabulary wars end when something runs.
Pair this with Steinberger’s OpenClaw / multi-agent world: the meme is funny because the certification is self-issued the moment your drawing runs end-to-end.
Related on explainx.ai
- AI burnout — focus and followthrough
- Graph engineering — multi-agent orgs after loops
- Graphs vs loops — Linear, Andrew Ng, orchestration debate
- What is loop engineering?
- Loop engineering — design loops that run while you sleep
- Zen of parallel programming — sync before scaling agents
- Fable 5 advisor / orchestrator patterns
- Claude of Duty — harness > vibes
- YC Fall 2026 RFS — Multiplayer AI
Primary sources: Alex Kotliarskyi’s July 25 X “graph-max” post · Peter Steinberger quote-tweet · circulating resident/ephemeral workflow sketch · Superlinear / Christine Yip loops-and-graphs pointers · explainx.ai graph-engineering hub (Jul 18).
Model names and product surfaces (Codex code mode, Sol) change quickly — re-check OpenAI’s current routing before you pin production spend to this recipe.