OpenAI Gave Away the Loop. The Meter Stayed.
Three labs published the other half of the agent in six weeks.
The event is not a product note. The field now names the object this series exists to study.
SpaceXAI put Grok Build on GitHub under the Apache 2.0 license. You can read the agent loop, the tools, the terminal user interface (TUI), and the extension system. You can compile it and point it at your own inference.
DeepSeek put DeepSeek Harness on GitHub under the MIT License. Every layer is a plugin: model, tools, skills, sessions, sandboxes, storage, the loop, and the user interface (UI). The README states the same formula this publication uses. Agent equals model plus harness.
OpenAI then put the Codex loop on GitHub under the Apache 2.0 license. OpenAI told you to build products on it. A JavaScript Object Notation Remote Procedure Call (JSON-RPC) app server owns your threads and turns. The server streams every event. The server cancels a running turn on request. The server stops at a seam where your application asks a person whether the agent may write the file. The control surface is documented. The control surface is yours.
Technically, Claude Code released its source code to the world first. They just did it by accident.
The model did not become less important. The labs just admitted that the model is not the whole agent.
Grok Build, DeepSeek Harness, and Codex sit on the bench. The meter stays locked.
Why this moment belongs to harness engineering
Strip the model weights out of an agent. The remainder is the harness.
Birgitta Böckeler records the shorthand on martinfowler.com. The harness is everything in an AI agent except the model itself. An agent equals a model plus a harness (martinfowler.com).
The survey Agent Harness Engineering: A Survey fills in the parts with a seven-layer map it calls ETCLOVG. The layers are execution environment, tool interface, context management, lifecycle and orchestration, observability, verification, and governance (openreview.net).
This publication uses a tighter production list. A harness assembles context. The harness binds tools to contracts. The harness keeps durable state. The harness observes the run. The harness recovers from failure. The harness coordinates people and other agents. Those six jobs are the work the model cannot do alone.
OpenAI uses a tighter definition for Codex. OpenAI calls the harness the agent loop and logic that underlies all Codex experiences. OpenAI names three jobs: thread lifecycle and persistence, config and auth, and tool execution and extensions (openai.com).
Grok Build publishes the same layer as source. SpaceXAI says the code is how context is assembled, how model replies are parsed, and how tool calls are dispatched (x.ai, github.com).
DeepSeek publishes the same layer as a plugin kernel. Models, tools, skills, sessions, sandboxes, filesystems, loops, orchestration, and UI are all plugins (github.com).
Three different houses. One object. The match is the proof. Harness engineering is no longer a metaphor. Harness engineering is the artifact the labs now ship.
The Codex release is the one that asks you to bet on a product. Read the repository and the offer holds up. Then read the number the same pitch leads with.
OpenAI moved GPT-5.6 Sol from 13.3 percent to 38.3 percent on the ARC-AGI-3 public task set. OpenAI used about six times fewer output tokens. OpenAI offers that jump as proof that harness design decides outcomes. The two changes that produced the jump are not in the repository. The two changes are settings on a metered application programming interface (API).
The scaffolding is open. The behavior that makes the scaffolding worth having is rented. A team that reads the announcement as a single offer will plan a product around a result that the free half cannot produce.
The useful question is not whether the harness is real. The harness is real. You can clone it this afternoon. The question is which half you get to keep. The next question is what the other half costs when you find out you cannot.
Dear subscribers and friends,
Sign up for this 5-hour seminar on Harness Engineering
Engineering Reliable Agentic AI Systems — Workshop
Engineering Reliable Agentic AI Systems
Saturday 29 August. Four hours. Hands-on the entire time. Please sign up.
Every module ends with work you keep and can run on Monday:
A working autonomous agent loop that runs on your machine in the first hour
A reusable evaluation harness that plans, executes, verifies, and iterates
A live research assistant built end-to-end over MCP
A production-ready architecture you can hand to your engineering org
This is a build session. You type for most of the four hours. You need comfort in a terminal. You do not need prior experience with agent frameworks.
Readers of this newsletter get 40 percent off with the code RICK40. The code expires on Friday, 28 August, the day before the workshop. There is no discount on the day.
Reserve a spot. Add RICK40 in the promo code box on the registration form.
The loop is open. The behavior that scores is metered.
What the app server owns that a command line tool does not
The repository that ships this Codex code is licensed Apache 2.0 (github.com). You can read every line of the argument that follows.
The terminal is the part you do not need. OpenAI describes the app server as two things at once. The app server is the JSON-RPC protocol between the client and the server. The app server is also a long-lived process that hosts the Codex core threads. The app server is built from a standard input/output (stdio) reader, a message processor, a thread manager, and the core threads (openai.com).
A command-line interface (CLI) process owns its threads in private. Those threads end with the terminal session that started them (github.com).
The app server holds the thread across clients and across reconnects. The integrated development environment (IDE) extension is one client of that process. OpenAI plans to make the TUI another client. The terminal client has so far run in the same process as the agent loop. The terminal client talked directly to the Rust core types, not through the app-server protocol (openai.com).
Your host application is a client too. The host application gets the same protocol the IDE extension gets.
The first harness lesson in the code is the distinction below. A command line tool is a session. An app server is a runtime. Products live on runtimes.
A command line tool is a session. An app server is a runtime.
Requests are control. Notifications are a feed.
You can check the boundary on the wire. You do not need to take it from a post.
JSON-RPC requests carry an id and demand a response. Notifications carry no id and expect nothing back.
The v2 thread and turn requests you can call are thread/start, thread/resume, thread/fork, thread/read, thread/list, turn/start, turn/steer, and turn/interrupt. Account, config, and model requests sit next to them (github.com).
turn/start adds user input and begins generation. turn/interrupt cancels an in-flight turn by (thread_id, turn_id). The call answers with an empty {}. The turn ends with status: "interrupted" (github.com).
Everything else that arrives at your client is a feed. turn/started, item/*, turn/completed, and thread/tokenUsage/updated stream while the turn runs.
Codex also ships a separate Model Context Protocol (MCP) server interface. The MCP interface exposes a rawer feed: a codex/event notification whose shape matches core/src/protocol.rs Event and EventMsg types. The MCP interface is a different binary, codex mcp-server. The MCP interface is not the app server (github.com).
Render those notifications. Log them. Or drop them. The agent behaves the same either way. Receiving an event is observation. Receiving an event is not permission.
The second harness lesson follows. Control is a request with an answer. Observability is a feed you can ignore.
The one place the runtime stops for you
Approval is the exception. Approval runs backwards. The server starts it.
The README says the app server drives an approval flow by sending a server-initiated JSON-RPC request to the client. The client must respond to tell Codex whether to proceed (github.com).
The v2 method is item/commandExecution/requestApproval. Your reply picks from accept, acceptForSession, acceptWithExecpolicyAmendment, applyNetworkPolicyAmendment, decline, or cancel.
You render the dialog. You do not enforce the outcome. If you refuse to render the dialog, the command still fails.
Two config fields stop the attractive mistake of treating the approval dialog as the security boundary. sandbox_mode and approval_policy are separate Option fields on ConfigToml (github.com).
sandbox_mode decides what is possible: read-only, workspace-write, or danger-full-access. The enum default is read-only (github.com).
Leave it unset in a directory that already carries a trust decision. The resolved mode is then workspace-write. The exception is Windows without the experimental sandbox. The mode stays read-only on that platform (github.com).
Under danger-full-access there is no filesystem sandbox. All commands are permitted (github.com).
approval_policy decides when the runtime pauses to ask: untrusted, on-request (the default), granular, or never (github.com).
The runtime evaluates both. A host that hides the approval dialog does not disable the sandbox. A host that returns a plain accept does not switch read-only into danger-full-access.
The narrower amendments are a real exception. An approval request can carry grantRoot for session-scoped write access. The request_permissions tool can ask for network and extra filesystem access. Answering those does widen what the agent can do (github.com).
The line you get is real. The line is drawn in code you can read. You own the interface and the answer. The Codex runtime owns the question.
The third harness lesson follows. Human-in-the-loop is not a dialog box. Human-in-the-loop is a policy the runtime still owns after you click.
Read the protocol and you know what you inherit. What you inherit is not what OpenAI advertises.
The dialog is yours. The sandbox is not.
The number that came from settings, not from weights
The headline number in the Codex platform pitch is a harness result. The harness that produced it is not the one in the repository.
OpenAI reports that GPT-5.6 Sol scored 13.3 percent on the ARC-AGI-3 public task set with the official harness. GPT-5.6 Sol scored 38.3 percent after two settings were turned on. The run used about six times fewer output tokens (OpenAI, OpenAI).
The Codex post cites that jump as proof that harness design changes results (OpenAI). The jump does prove that. The jump does not prove that the code you clone carries the gain. OpenAI says it built that run on the Responses API (OpenAI).
Look at what moved.
The first setting is retained reasoning. The official harness threw away the model's private reasoning after each game action. Every turn began with the model rediscovering the rules. Keeping those reasoning items across turns is API behavior. You chain them with previous_response_id. Or you run stateless with store: false. Each reasoning item then returns encrypted_content by default. You send it in the next request. The include: ["reasoning.encrypted_content"] flag still works and is no longer required (OpenAI).
The second setting is compaction. Compaction replaces a rolling truncation window with a server-side summary of prior context. Compaction has its own guide and its own compact method on the Responses endpoint (OpenAI).
Neither setting is harness source code. OpenAI presents both runs as the same model with two settings turned on, not as a new model (OpenAI).
The benchmark is why the swing is so large. ARC-AGI-3 is interactive. ARC-AGI-3 asks agents to explore new environments, acquire goals on the fly, build adaptable world models, and learn without a pause (ARC Prize).
A harness that forgets between turns reduces a reasoning model to a memoryless policy. Fixing memory on a memory benchmark is the single change most likely to produce 25 points. Treat the result as a strong finding about long-horizon agent loops. Treat the result as a weak finding about short-horizon work. No source shows the same lift there.
Now ask who ran it. OpenAI ran it. OpenAI reported it.
The ARC Prize Foundation publishes 7.78 percent for GPT-5.6 Sol Max on the ARC-AGI-3 semi-private set, entered on 2026-07-09 (ARC Prize).
The 38.3 percent figure appears nowhere on the ARC Prize results pages (ARC Prize).
OpenAI's 13.3 percent baseline does match the board. ARC Prize lists 13.33 percent for Sol on the public set on the same page. The two ARC numbers differ because they are different sets. No one disputes the difference (ARC Prize).
What no source settles is the 38.3 percent figure. ARC Prize agreed the finding was real. ARC Prize wrote that provider-managed conversation state preserves greater continuity across turns and improves performance on long-horizon tasks like ARC-AGI-3. ARC Prize called the finding a real and useful result. ARC Prize added that its verified scores use a no-harness approach to avoid accidental or intentional developer-aware targeting (ARC Prize).
Agreement about the cause is not verification of the score.
François Chollet drew the line the same day. The line does not fall where the dispute over the score falls. General-purpose API settings that were not developed for ARC-AGI-3 and that are available to all API users are fine, he wrote. Harnesses custom-made to solve the benchmark are not okay (Chollet).
Retained reasoning and compaction are general-purpose settings. His test clears the run. Clearing the method is still not verifying the number.
No one has rerun 38.3 percent under documented setting parity. No one has rerun the other models with the two settings on. Under ARC's own protocol, Claude Opus 5 sat ahead of Sol on this benchmark (ARC Prize).
Cost per task, attempt count, and effort tier are not disclosed. You cannot price the gain even if you accept it.
Take two things from the record.
Your own loop probably drops reasoning and truncates history. You can check both this afternoon.
Fixing them means calling the OpenAI metered endpoint. The endpoint bills on both sides. The model charges its reasoning as output tokens when it generates them (OpenAI). Every reasoning item you carry forward bills again as an input token on each later request in the chain (OpenAI).
The number argues for harness design. The number does not hand you a harness. The number hands you a bill.
The fourth harness lesson follows. Context management is a capability. If the only working implementation lives behind a vendor meter, you do not own that capability. You rent it.
The jump comes from two API settings, not from the open crate.
What stays metered and vendor-controlled
You pay for model access either way. An API key bills you per token. A ChatGPT plan bills you in credits. OpenAI computes those credits per million tokens and reports them as an estimated message count (Codex docs).
Nothing else in the harness costs money (Codex docs).
An open client used to bind you to an endpoint. An open harness binds you to the loop your product now wraps.
OpenAI publishes the Codex CLI, app-server, and official Codex software development kit (SDK) as open-source components. OpenAI draws the commercial line in the same post. The open-source layer is the harness and integration surface. Model access and managed services remain separate (OpenAI).
Two credentials meter that access in different ways.
A ChatGPT sign-in bundles Codex into a plan you already pay for. OpenAI estimates that plan at 10 to 100 local Sol messages per five-hour window on Plus, and 200 to 2,000 on Pro 20x. Cloud chats draw on the same window. Extra weekly limits can apply on top (Codex docs).
An API key bills per token through your OpenAI Platform account at standard API rates (Codex docs).
For gpt-5.6-sol the promotional short-context rate is $4.00 per million input tokens, $0.40 cached, and $20.00 per million output tokens. Long-context requests cost twice that on input and half again on output. OpenAI says the promotional price holds at least through November 21, 2026 (OpenAI).
At the short-context rate, output costs five times input and fifty times cached input. Once a thread crosses into long context, output stays at least 3.75 times input and 37.5 times cached input.
An agent loop is an output machine. The ratio is why the token savings in the last section land on the expensive side of the meter.
The credential choice is not only a price. The credential choice picks your data policy.
ChatGPT sign-in puts Codex under your ChatGPT workspace permissions, role-based access control, and ChatGPT Enterprise retention and residency settings. An API key puts it under your API organization retention and data-sharing settings instead (Codex docs).
The API key path is the one an embedded product can drive. The API key path is also the one that loses ground. Some features that rely on ChatGPT workspace access or cloud services are limited or unavailable. Codex cloud requires signing in with ChatGPT (Codex docs).
Now the question that decides how deep the lock goes. Can you point this harness at a model OpenAI does not host?
You can. The configuration reference documents a model_providers table for custom endpoints. The table reserves three built-in provider IDs: openai, ollama, and lmstudio (Codex docs).
A fourth built-in provider, amazon-bedrock, routes requests through Amazon Web Services (AWS) rather than OpenAI. The provider still routes only to OpenAI own models. Every supported model ID on that page begins openai.. The provider moves the host and the invoice. The provider does not move the vendor (Codex docs).
Local inference has its own switch. Codex can run against a local open source provider such as Ollama or LM Studio when you pass --oss (Codex docs).
The base URL is a setting.
Read one line further and the real gate appears. wire_api is the protocol used by the provider. responses is the only supported value. responses is the default when omitted (Codex docs).
Your endpoint must implement OpenAI Responses API. The requirement is narrower than the OpenAI-compatible Chat Completions surface most vendors ship.
The gap is closing at the local end. Ollama now documents a Responses endpoint beside its Chat Completions one (Ollama).
A competing model still reaches this harness by imitating OpenAI interface. OpenAI gave away the loop and kept the wire format the loop speaks.
A second gate follows the money. requires_openai_auth marks a provider that uses OpenAI authentication (Codex docs). A ChatGPT plan buys OpenAI model access. Routing to a third-party model means paying that vendor and giving up the plan.
Coverage also thins as you move up the stack. The CLI documents multi-provider support. The app-server is provider-aware, with modelProvider/capabilities/read and a thread/list filter on modelProviders (Codex docs).
The Codex SDK documentation selects a model per thread. The documentation never mentions a non-OpenAI or local provider (Codex docs). Read the silence as silence.
None of the strategy is new. Give away the client. Sell the inference.
What changed is the size of the piece on offer. An open API client wraps a transport. An open harness takes over the agent loop, the sandbox, the approval seam, and the thread store.
OpenAI says as much. Your application owns product context, business rules, and tools. Codex app-server provides the agent loop and sandboxed execution (OpenAI).
The open loop moves the commercial boundary from access to the client into the behavior of the loop itself. Adopting a client is a swap you can scope. Adopting a harness shapes your threads, your approval gate, and your event stream. Leaving costs you a rewrite of the integration, not an edit to a base URL.
Place Codex next to the other two open harnesses and the map gets sharper.
Grok Build is Apache 2.0. SpaceXAI published the loop and said you can compile it and point it at local inference (x.ai).
DeepSeek Harness is MIT. DeepSeek published the loop as replaceable plugins, including the model adapter (github.com).
Anthropic ships the Claude Agent SDK code under an MIT license (GitHub API). Anthropic governs use by Anthropic Commercial Terms of Service (Anthropic). The SDK reaches Claude models only through metered hosts. The hosts are an Anthropic API key, Amazon Bedrock, Claude Platform on AWS, Google Cloud Agent Platform, and Microsoft Foundry (Anthropic).
Google ADK is Apache 2.0 (GitHub API). Google ADK ships adapters that connect with many other models and model providers, including locally running models (Google).
Codex sits between them. Codex is more open than Anthropic on model choice, if not on license. Codex is less neutral than Google. Google adapts to other vendors. OpenAI asks other vendors to adapt to it.
The commercial shape is checkable in the documentation. The customer evidence in the same announcement is not.
The source is open. The wire format and the meter are not.
Read the proof points before you believe them
Start with a mismatch you can see without leaving the page.
The announcement argument is that the app-server is the seam where you put an agent inside your own product. The customer section is headed “What developers are building”. The section names GitHub and JetBrains for IDE integration. The section names Cisco for the Codex SDK. The section names Thrive Holdings and Crete for a tax workflow (announcement).
None of them is cited as an app-server user.
The one app-server example is Relay. Relay is a sample operations application on Codex app-server. Relay has a fictional shipment dashboard and human approval before a shipment is rebooked (announcement).
The strongest architectural claim in the post rests on a demo.
Then check the dates. The tax figures first appeared on May 27, 2026. The figures were 7,000 returns and preparation time cut by about a third. The figures sat on a page called “Building self-improving tax agents with Codex” (OpenAI).
The August post links to that page. The reuse is open rather than hidden. What changed is the claim the numbers are asked to support.
In May, the figures supported an eval-driven improvement loop for one vertical agent. Certified public accountants (CPAs) correct drafts. Corrections become evals. Codex proposes fixes.
In August, the same figures sit under a pitch for an open harness. One measurement cannot carry both claims.
Cisco deployment has the same shape. The announcement reports Cisco accurately. It reports an SDK integration. Cisco published it itself on June 2, 2026, eleven weeks before the announcement. Cisco wrote that users can now use Codex directly inside Cisco Cloud Control, powered by the Codex SDK (Cisco).
The same post calls Cisco OpenAI's earliest design partner for Codex. The post carries a forward-looking disclaimer. Described features may be in various stages of development and offered on a when-and-if available basis (Cisco).
A design partner running a feature in controlled availability is weaker evidence than a customer in general availability (Cisco newsroom). The Cisco post is evidence about the SDK, not the app-server.
Now ask who owns whom. OpenAI took an ownership stake in Thrive Holdings in December 2025. Crete is a Thrive portfolio company. TechCrunch summary of the arrangement is that OpenAI profits when those companies scale based on growth its work helped generate (TechCrunch, Reuters).
The stake does not make the pilot numbers false. Nothing found refutes them. The stake makes them interested-party reporting. Interested-party reporting earns a different discount than an arm-length case study earns.
Finish with the baseline. “Reduced preparation time by about a third” has no published methodology, no control group, and no released eval set.
Crete own materials put an “up to 97% drafting accuracy” figure on the same pilot (Crete). The August post leaves that figure out. The figure has no published denominator either.
Every statement of these figures traces back to OpenAI, Thrive, or Crete. A percentage nobody outside the deal has measured is a claim, not a measurement.
The contrast is what makes the record useful rather than cynical. The code in this announcement is checkable. The customer evidence is not.
Clone tag rust-v0.149.0 and you will find codex-rs/app-server present (repository).
You will not find a Relay sample application anywhere in the tree. There is no examples directory at the repository root. The only relay paths belong to the exec-server Noise transport (GitHub API).
Five minutes gives you a verdict on the harness. No amount of reading gives you one on the pilot. Judge the part you can run. Treat the rest as marketing that happens to carry a date.
What you actually get
Draw the line where the code draws it.
You own the client. You own the approval dialog and the answer you send back. You own the thread store your product wraps. You own the event stream you render or drop. You own the sandbox mode and the approval policy you configure. Both hold whatever your interface does.
Clone the repository. Those items cost you nothing.
OpenAI owns the rest. OpenAI owns the weights. OpenAI owns retained reasoning and compaction, the two settings that tripled its own benchmark score. OpenAI charges twice for the reasoning they retain. OpenAI bills once as output when the model writes it. OpenAI bills again as input on every later turn in the chain. OpenAI owns the wire format a competing provider has to imitate before your harness can reach it at all.
What changes for you is the shape of the decision, not its difficulty. Adopting Codex is not picking a model. Picking wrong does not unwind with an edit to a base URL. You are choosing whose loop your threads, your approvals, and your events are built to fit. Price it as an integration you rewrite if you leave. Do not price it as a client you swap.
Two things are worth doing before you commit.
Check whether your current loop throws away reasoning between turns and truncates history instead of summarizing it. The ARC-AGI-3 result says that is where the points are. You can test it against any API you already pay for.
Then take the harness for exactly what it is. The harness is real. The harness is readable. The harness is free. The harness sits in front of a meter you do not control.
Judge the part you can run. Everything else in the announcement is a claim with a date on it.
What this proves about the discipline
Grok Build, DeepSeek Harness, and Codex did not make harness engineering true. The three releases made it visible.
A year ago the argument still sounded like taste. Builders said the runtime around the model decided whether an agent survived contact with production. Labs talked about models. The public talked about models. The failures kept showing up in context assembly, tool contracts, memory, observation, recovery, and orchestration.
Now the labs publish those layers as named artifacts. The labs license them. The labs tell you to embed them. The labs also keep the pieces that move the score behind a meter and a wire format.
The split is the discipline.
If you treat the open loop as the whole offer, you will ship on rented behavior. If you treat the open loop as a control surface you can read, fork, and measure, you will know which half you own.
The work has not changed. The evidence has.
Clone the three trees. Compare how each one keeps a thread, stops a tool, and asks a person. The comparison is harness engineering. The meter is the rest of the business.
Clone the trees. Compare the loops. Price the meter separately.
Next read: Harness Engineering
Book a working session: calendar
If you are a paid subscriber, thank you. Your support makes this work possible.
If you are a free subscriber and find these articles useful, please consider upgrading. A paid subscription is $80 per year or $8 per month.
Free subscribers typically receive access to the full versions of paid articles after one to two months.
About the Author — Claude Certified Architect
Rick Hightower is a former Senior Distinguished Engineer at a Fortune 100 company, focusing on delivering ML / AI insights to front-line applications, and a practitioner building multi-agent production systems. Follow him on SubStack and Medium for more hands-on agent engineering content. You can also book him to speak and train your team: Check out Rick Hightower’s SpeakerHub.
Rick Hightower helps companies become AI-first through practical mentoring, executive and team training, and custom AI solution development. He is a former Senior Distinguished Engineer at a Fortune 100 company, where he focused on bringing ML and AI insights into real front-line business applications.
Subscribe to Rick’s newsletter to see videos and guides.
Rick is a Claude Certified Architect, AI systems practitioner, and builder of production multi-agent systems. He is currently working on authoring a book on Harness Engineering with Manning Publishing. He created Skilz, a universal agent skill installer supporting 30+ coding agents, including Claude Code, Gemini, Copilot, and Cursor, and co-founded one of the largest agentic skill marketplaces.
Today, Rick and the Spillwave team work with leaders and teams who want to move beyond AI experiments and build real AI capability inside their companies. He helps organizations adopt AI safely, train their people, redesign workflows, and build practical AI systems that create measurable business value.
Ready to make your company AI-first? Connect with Rick on LinkedIn, Substack, or Medium, book him to speak or train your team, or visit Spillwave to explore mentoring, training, and custom AI solutions for your organization.
If this helped you, please consider subscribing to my Substack newsletter.
Likes, comments, and shares really do make a difference. They help grow the channel, support the work, and get these ideas in front of more builders who are trying to understand AI agents, harness engineering, and production AI systems.
Thank you for reading and for helping the work reach more people.
Dear subscribers and friends,
Sign up for this 5-hour seminar on Harness Engineering
Engineering Reliable Agentic AI Systems — Workshop
Engineering Reliable Agentic AI Systems
Saturday 29 August. Four hours. Hands-on the entire time. Please sign up.
Every module ends with work you keep and can run on Monday:
A working autonomous agent loop that runs on your machine in the first hour
A reusable evaluation harness that plans, executes, verifies, and iterates
A live research assistant built end-to-end over MCP
A production-ready architecture you can hand to your engineering org
This is a build session. You type for most of the four hours. You need comfort in a terminal. You do not need prior experience with agent frameworks.
Readers of this newsletter get 40 percent off with the code RICK40. The code expires on Friday, 28 August, the day before the workshop. There is no discount on the day.
Reserve a spot. Add RICK40 in the promo code box on the registration form.