All articles
Knowledge continuity

Agent factories: what OpenAI's Performance Factory teaches about governed work

OpenAI's Performance Factory runs agent workflows for performance debugging: over 1,700 investigations in three months. The transferable lesson for enterprises is the plumbing — task state, versioned skills with evals, scoped service identities and human gates.

CogLake Redaktion · 21 November 2026 · 6 min

This article was created automatically with AI support.

The unit of work is the task, not the prompt. On 19 November 2026 OpenAI described how Codex agents investigate performance problems in ChatGPT, propose fixes, and then check whether latency has returned to its baseline. The numbers are unspectacular and concrete: in just over three months, the first workflow tracked more than 1,700 investigations and root-caused over 600 cases — about 17 automated investigations every day. For anyone building agents for knowledge work, the interesting part is not the performance engineering. It is what was built around the agents.

Four components instead of a chat

OpenAI names four parts:

  • A task service with configurable workflows. Workflows are configuration files plus Markdown prompts. The configuration lists the states a task may move through, the transitions that are allowed, and which steps need an engineer.
  • A dispatch loop. It periodically checks which task is ready for the next step, starts a Codex turn with the instructions for the current state, and the agent records its progress and moves the task on.
  • Codex in the cloud. An internal API runs Codex inside the corporate network, with access to repositories and the observability tools engineers use: metrics, logs, traces, CPU profiles, memory snapshots. Agents run under a service identity, so permissions can be scoped and actions attributed.
  • Subscriptions. When a task has to wait for a person or a deployment, it subscribes to events such as a review comment or a failed CI check. When the event arrives, the task becomes ready again.

The first workflow mirrors the stages the team already had: needs investigation → root caused → fix proposed → resolved. An engineer does the review and the deployment. After deployment, an agent checks whether performance is back to baseline before the task is closed.

The sentence that matters for knowledge work

One remark in the post separates this from most internal agent pilots: the task records its status and key findings outside of any one agent's context, so that other agents or engineers can pick up the work.

That is the handover problem enterprises already have with people — now it applies to agents too. In many pilots, the intermediate state lives in a chat session. When the session ends, the reasoning is gone and the next person starts over. A task record with status, findings, decision owner and timestamp is a knowledge artifact: reviewable, transferable, reconstructible.

Six stages — and where most teams actually are

OpenAI describes its own path in six steps: manual work before Codex; Codex as a partner that can investigate an unfamiliar system; reusable skills; the human as a proxy who pastes alerts into the agent and pastes findings back; automated investigations in the cloud that end with a Slack reply; finally the factory that manages states and responsibilities.

Stage four is an honest description of many "AI workflows" in enterprises today: a person as the interface between two systems. That is not a failure, but it does not scale — and in a demo it looks like automation. The jump to the factory is not a better model; it is state management.

Skills need evals, not prose

The core skill is called perf-forensics. It tells Codex which tools exist, when to use them, and how to narrow down a slowdown: when it began, which requests were affected, whether deployments or configuration changes explain it. The team tested and refined the skill with evals based on past regressions.

That is the part enterprises often skip. A Markdown playbook is written quickly; without a test set drawn from real cases, nobody knows whether the agent applies it correctly. Anyone introducing a skill should bring twenty closed cases with known outcomes — and measure how often the agent reaches the same finding.

Permissions are part of the design

Agents run under a service identity, not an employee's account. That allows permissions to be narrow and makes it visible which action came from an agent. In a companion post on 18 November, OpenAI describes the Codex sandbox: conservative defaults, write access inside the workspace, filesystem reads within the limits of the operating system, no network by default.

What is notable is the honesty about limits: the sandbox prevents a large class of bad behavior, but not harmful actions in general. OpenAI gives an example — an agent could inject code into a locally installed package such as node_modules/prettier; that change often does not show up in git status, and the editor executes it outside the sandbox when the file is saved. Hence defense in depth.

For knowledge agents the lesson is that read access is the real lever. An agent allowed to read every repository also reaches payroll files and contracts if nothing separates them. The sandbox protects against the network, not against the wrong file.

The bottleneck moves to review

OpenAI writes that today the bottleneck may be waiting for the engineer to review and merge the fix, and that it is exploring whether agents can do this themselves. That is the honest metric: automate production without automating review and you have built a queue. Review time, not the model call, is the cost centre.

Five questions before copying the pattern

ComponentWhat OpenAI describesQuestion for your team
Task stateStatus and findings outside the agent's contextWhere does the task live, who may edit it, how long is it retained, can an auditor reconstruct it?
SkillsMarkdown playbooks with tool accessVersioned, with an owner and evals from real cases?
Human gateReview and deployment by an engineerWhich transitions require a named role — and is that enforced by configuration rather than convention?
IdentityService identity with scoped permissionsOne identity per agent, least privilege, an action log?
VerificationAgent checks recovery before closingWhat is your baseline check, and what happens when it fails?

What this article does not prove

It is a vendor report about its own workflow, with no independent review. The numbers are self-reported. And performance work has an objective target: latency returns to baseline or it does not. Knowledge work often has no such target. An agent that closes a ticket is not evidence that the answer was right.

The transfer is therefore a design pattern, not a measured result. Anyone adopting it should keep the difference between "ticket closed" and "outcome verified" visible — in the state model, not in a footnote.

A pilot that costs a week

Take ten recurring tasks with known outcomes, such as proposal checks, contract questions or complaint analyses. Write down the states and allowed transitions, mark the step that needs sign-off, and draft one skill for the actual work. Define how you will recognise that a task is genuinely done. Then measure three things: the share of tasks that reach verification, review minutes per task, and rework. Those are the numbers that belong in a procurement decision — not the count of agents launched.

This article is based on published vendor documentation; we did not run our own tests. It is not technical security or investment advice.

Sources

Sources retrieved on 21 November 2026.

Turn company knowledge into governed context.

See how CogLake fits your sources, permissions, and AI interfaces.

Book a walkthrough