Everything About Codex: The Complete Guide to OpenAI’s Coding Agent

How OpenAI’s coding agent works under the hood, where it fits in modern software engineering, what it costs, where it breaks, and how organizations are deploying it at scale

Codex is no longer a single tool. It is a family of surfaces sharing one underlying agent.

I wrote this to be the single article you need to understand Codex, from a standing start to an advanced, working mental model. If you have never run a coding agent, you should finish this able to reason about how Codex is built, what it costs, where it is safe to trust, and how serious engineering organizations are putting it into production. If you already use it daily, my goal is to give you the internals and the economics that most coverage skips.

Most articles about Codex stop at what it does. They show a demo, list a few features, and move on. This guide goes further on purpose. I want to explain how Codex works internally, where it fits inside a modern software development lifecycle, what breaks when you scale it across thousands of repositories, and how teams are actually deploying it. Capability is the easy part of the story. The hard and interesting parts are architecture, cost, and trust.

A word on sourcing, because credibility matters. Everything here is built on publicly available documentation, OpenAI’s own engineering write-ups on the Codex agent loop and harness, research papers, published benchmarks, and industry analysis. I am synthesizing the public record, not recounting a personal deployment. Where numbers come from a single vendor or a single benchmark, I say so, because in this field the scaffolding around a model often matters as much as the model itself.

THE FRAME FOR THIS GUIDE

Treat Codex less like a smarter autocomplete and more like a junior engineer you supervise: it reads the repo, runs tests, and proposes changes, but you still own the review and the architecture.

The core thesis: from AI-assisted coding to AI-driven engineering

Here is the argument the rest of this guide defends. Codex represents a transition from AI-assisted coding to AI-driven software engineering. The distinction is not marketing. It is a change in what the tool is responsible for.

Traditional tools helped you write code. Autocomplete finished your line. Copilot suggested the next block. Chat assistants answered questions while you stayed in the driver’s seat. Codex is built to take the wheel for a bounded task. It is designed to read repositories, understand project structure, execute engineering tasks, run tests, fix bugs, generate pull requests, and operate with meaningful autonomy inside development workflows.

That shift changes the unit of work. The old unit was a keystroke or a suggestion. The new unit is a task with an outcome: a green test suite, a merged pull request, a refactor that compiles. When the unit of work becomes an outcome rather than a suggestion, the human role moves from author to reviewer and supervisor. That is why this is a genuine inflection point for software engineering, and why it deserves a careful look rather than a hype cycle.

Each era widened the agent’s autonomy. Codex sits at the far end, acting on tasks rather than suggesting lines.

The evolution of AI coding

To see why Codex feels different, it helps to trace the path that led here. The progression has been steady, and each step expanded how much the tool could do without a human in the loop.

• Early autocomplete predicted the next token or line from local context. Useful, but it never left your cursor.

• GitHub Copilot brought large-model suggestions to the mass market in 2021 and 2022, completing whole blocks inline and proving developers would accept AI-written code.

• AI pair programming and chat assistants added conversation. You could ask why a function failed or request a rewrite, but you still applied the changes yourself.

• Coding assistants in the IDE like Cursor began chaining edits across files, inching toward multi-step work under close supervision.

• Autonomous coding agents such as Codex and Claude Code crossed the line: they navigate a repository, run commands, execute tests, and open pull requests with limited intervention.

Why is Codex different from what came before? Because it unifies that autonomy across surfaces and wires it to a model trained specifically for the job. The first Codex Cloud preview in May 2025 ran on codex-1, a version of OpenAI’s o3 reasoning model optimized for software engineering through reinforcement learning on real coding tasks, trained to iteratively run tests until they pass. By 2026 the family had moved onto GPT-5.5, OpenAI’s agentic-first base model. The point is not any single model version. It is that Codex pairs a coding-tuned model with an agent harness that can actually act.

What Codex actually is

Codex in 2026 is not one product. It is an umbrella for several surfaces that share a single account, a single underlying model, and a single agent engine. Understanding the surfaces is the fastest way to understand the product.

Codex CLI

The terminal-native agent, first released in April 2025 and developed in the open under a permissive license. It reads your repository, edits files, runs tests, and commits code without leaving the shell. It is the most actively developed terminal coding agent outside Anthropic’s, with tens of thousands of GitHub stars and hundreds of contributors, and it supports MCP servers and parallel tool calls.

Codex Cloud

Announced as a research preview in May 2025, this is the delegated mode. You hand Codex a task and it runs in its own isolated cloud sandbox preloaded with your repository. You can launch many tasks in parallel and watch them progress, then review the proposed changes. This is the surface that most clearly embodies the shift from assistance to delegation.

IDE integrations and the desktop app

Codex plugs into VS Code, Cursor, and Windsurf, and ships as a desktop app for macOS and Windows that is designed to manage multiple agents at once and supervise long-running work. The same agent that runs in your terminal runs in your editor.

Multi-agent workflows, repository understanding, and sandboxes

Codex shipped a generally available subagent model with a manager that can coordinate several parallel workers, each with its own context. It builds an understanding of a repository from its structure and from project instruction files, and every task executes inside a cloud sandbox so the agent’s actions are contained. These three ideas, multi-agent coordination, repository understanding, and sandboxed execution, are the backbone of everything that follows.

ADOPTION IN NUMBERS

Codex grew to more than two million weekly active users by March 2026, and OpenAI cited roughly four million weekly developers at the GPT-5.5 launch in April 2026. Enterprise uptake is real too: more than ten thousand employees at NVIDIA were given access to Codex across engineering and non-engineering functions, a signal that this is no longer a developer-only tool.

How Codex works under the hood

This is the part most coverage skips, and it is the most useful to understand, because it explains both the behavior and the bills. OpenAI engineers have published unusually detailed write-ups of the Codex agent loop and harness, and the picture they paint has three layers worth knowing: the agent loop, prompt and context management, and the shared harness that serves every surface.

The agent loop

At the heart of Codex is a loop. The agent takes your input, assembles a prompt, sends it to the model, and gets back a response. Crucially, that response is not always a final answer. Often it is a tool call: run this shell command, edit this file, read this part of the repo. Codex executes the tool, appends the result to the conversation, and runs inference again. Each cycle of inference and tool calls is what OpenAI calls a turn, and a turn repeats until the task is done.

The agent loop. Inference may return a tool call rather than an answer, so the cycle repeats within a single turn.

When you send a follow-up message, the entire history of previous turns, including every tool call and its output, gets replayed into the next prompt. This is exactly where costs grow, because the prompt keeps getting longer. Codex manages this in two ways. When the context window fills, it compacts the conversation into a smaller representative state so the agent keeps its understanding without carrying every raw token forward. And it leans heavily on caching, which brings us to context management.

Context management, planning, and caching

When you make a request, your message becomes the bottom layer of a much larger prompt. Above it, Codex stacks environment context like your working directory and shell, the contents of any AGENTS.md files in your repository (project-specific instructions covering conventions and which test commands to run), sandbox permission rules, developer configuration, model-specific instructions, and the tool definitions.

The prompt is layered with static content first, so the cached prefix can be reused across turns at a fraction of the cost.

The ordering is deliberate. Static content sits at the front so OpenAI’s prompt caching can reuse it. The first time a prefix is sent, the model’s state for that prefix is cached; later turns that share the prefix skip recomputation. Cached prefix tokens cost roughly a tenth of fresh input tokens, which is why the quadratic growth in tokens sent does not translate into quadratic cost growth. A practical consequence: keep your AGENTS.md stable during a session, because changing it mid-session invalidates the largest cached prefix. Codex’s 2026 migration to the Responses API was reported to improve cache utilization substantially and to lift its SWE-bench score by freeing compute for reasoning within the same budget.

Tool execution, testing, and pull request generation

The tools are where the agent meets the world. Codex executes shell and file operations inside the sandbox, and wires up integrations like MCP servers and skills so they can participate in the loop. Testing is first-class: codex-1 was trained to run tests and iterate until they pass, which is why a well-configured test suite improves results so much. When the work is done, Codex packages a diff, the test results, and a summary into a pull request for human review. The agent does the labor; the human keeps the merge button.

THE KEY INSIGHT ABOUT COST

Every follow-up turn replays the full history, so token usage grows with conversation length. Caching softens the blow, but the cheapest sessions are focused ones with stable instructions and bounded scope.

Codex architecture deep dive

Step back from a single task and the system architecture comes into view. The design goal is to let many agents work at once without stepping on each other, while keeping a human in control of anything risky.

Each task gets an isolated sandbox and its own git worktree, so parallel agents never collide. Sensitive actions pause for approval.

Sandbox environments and worktrees

Each task runs in its own isolated cloud sandbox, preloaded with your repository. On the local CLI, Codex uses git worktrees so that parallel tasks operate on separate working copies of the same repo. The combination means a feature task, a bug fix, and a refactor can run simultaneously without conflicting edits.

Parallel execution and task orchestration

Above the sandboxes sits orchestration. The subagent model uses a manager that decomposes work and dispatches it to parallel workers, each with a dedicated context window for its subtask. This is what lets Codex, in OpenAI’s framing, complete what used to be weeks of work in days, by running independent threads of work at the same time rather than serially.

Tool calling and human approval checkpoints

Tool calls are gated by an approval model. Codex was deliberately launched without general internet access for security, with optional network access added later under user control. Actions that reach outside the workspace, touch the network, or run risky commands can pause for human approval depending on the configured mode. This is the seatbelt that makes delegation safe: the agent can move fast inside the sandbox, but it asks before doing something that could matter outside it.

Codex vs ChatGPT vs Copilot vs Cursor vs Claude Code vs Devin

These tools are often lumped together, but they occupy different points on two axes: how autonomously they act, and where they live in your workflow. Mapping them that way is more useful than any feature checklist.

The same task can be served by very different tools. The axes that matter are autonomy and where the tool lives.

ChatGPT and GitHub Copilot

ChatGPT is the lowest-friction option: conversational help where you copy and paste. Its strength is breadth and zero setup; its weakness is that it does not touch your repository or run anything. Copilot pioneered inline completion and remains excellent at in-editor suggestions. Its strength is flow; its weakness is that it is fundamentally an assistant, not an agent, so it does not own a task end to end. Both are cheap and ideal for ideation and small in-context edits.

Cursor

Cursor is an agentic IDE. It chains multi-file edits and runs an agent inside a polished editor, which makes it a strong fit for developers who want autonomy without leaving a graphical environment. Its weakness relative to Codex and Claude Code is that it is editor-bound, so delegated and headless workflows are less natural.

Claude Code

Claude Code is the closest peer to Codex: a terminal-first autonomous agent that reads repos, runs tests, and opens pull requests. The two trade benchmark leads depending on the variant. Independent analyses consistently report that Claude Code tends to use more tokens per task and produce more thorough, exhaustive output, which helps on large refactors and nuanced review, while Codex tends to be more concise. One widely cited build task reportedly used about 1.5 million tokens on Codex versus 6.2 million on Claude Code. Treat that as one data point, not a law, because efficiency varies by task.

Devin

Devin from Cognition is the most managed option: a hosted AI software engineer with a web interface, priced for enterprises. Its strength is the fully managed experience and a deliberate push into regulated and government deployments. Its weakness is that on unassisted SWE-bench Verified it scores lower than agents built on the strongest base models, and at a high monthly price it suits teams that want a turnkey managed agent rather than a raw, scriptable one.

HOW TO CHOOSE

Pick ChatGPT or Copilot for inline help, Cursor for agentic work inside an IDE, Codex for multi-surface and parallel delegation that is token-efficient, Claude Code when thoroughness on hard refactors matters more than token count, and Devin when you want a fully managed engineer and will pay for it.

The economics of agentic software engineering

This section matters more than any benchmark, because economics decide whether an agent is used or shelved. Agentic coding has a cost shape that surprises teams used to flat-rate tools.

Token consumption and inference economics

Recall the agent loop: every turn replays history, and complex tasks fan out into many model calls. In April 2026 Codex moved to token-based billing where credits consumed equal input tokens times their rate, plus cached input at roughly a tenth of that rate, plus output tokens. OpenAI’s guidance is that a typical Codex task on GPT-5.5 consumes somewhere between 5 and 45 credits, and that cached input is the single most important cost lever in agentic workflows. This is why prompt and AGENTS.md discipline is not housekeeping; it is the cost model.

Cost rises with the number of model calls a task requires. Token efficiency differs by tool and by task type.

Cloud execution and cost per task

Translated to dollars, published 2026 analyses put a simple agentic task near twelve cents, a complex one in the range of forty to sixty-five cents, and a debugging-heavy task that loops several times higher still. The danger is the loop: a flaky test or circular dependency can send the agent into ten or twenty retries, each replaying the full history. The mitigation is to cap turns and set token limits on automated runs. At the team level, OpenAI estimates roughly one hundred to two hundred dollars per developer per month, and enterprise audits put the effective per-developer cost around one hundred thirty to two hundred ten dollars at scale, with compliance and admin controls included.

Engineering productivity gains

Against those costs sit productivity gains, and here the credible evidence is encouraging but nuanced. A longitudinal enterprise study of AI coding-agent adoption found a 31.8% reduction in pull request review cycle time, strong satisfaction, and adoption scaling from 4% in month one to a peak of 83% by month six before settling near 60% steady-state. Top adopters pushed 61% more code to production. Separately, OpenAI has reported that teams cut manual review time by around 60% when Codex pre-screens pull requests. The pattern is consistent: real gains, concentrated among engaged users, with a settling period after the novelty fades.

Review cycles shorten and adoption climbs, then settles. Gains concentrate among engaged users rather than spreading evenly.

Codex at enterprise scale

Everything changes when you move from one developer to thousands of repositories and hundreds of engineers. At that scale, the interesting questions are not about capability but about governance, integration, and control.

At enterprise scale, Codex runs headless in CI on every pull request, wrapped in policy, scoped permissions, and audit logging.

CI/CD integration

The highest-leverage enterprise pattern is headless execution in the pipeline. Teams run codex exec on every pull request to pre-screen reviews, generate tests, update documentation, and handle routine fixes, then route the result to a human gate before merge. CI/CD is also where caching pays off most, because the same repository context, the AGENTS.md, structure, and test patterns, is sent with every automated invocation, so the cached prefix is reused constantly. OpenAI has built example integrations with deployment platforms like Vercel, Netlify, and Cloudflare to smooth the path from generation to release.

Governance, security controls, and compliance

Across thousands of repositories, the controls are the product. Administrators can manage plugins through policy settings and private marketplaces, distributing, permitting, or blocking specific plugins across teams. Repository permissions must be scoped so an agent only touches what it should, secrets must be isolated from the sandbox, and every action should be logged for audit. The governing principle is least privilege applied to agents the same way it is applied to human identities, an asymmetry that, as we will see in the security section, attackers are actively exploiting where it is missing.

THE ENTERPRISE REFRAME

At scale, the question is never can Codex write the code. It is can you prove what every agent touched, constrain what it can reach, and review what it ships. Governance is the feature that turns a capable agent into a deployable one.

Where Codex excels

Codex is strongest where the work is well-defined, verifiable, and tedious. These are the tasks where an agent that runs tests and iterates has a structural advantage over a human doing the same thing by hand.

• Refactoring at scale, where the change is mechanical but sprawling, and a passing test suite confirms correctness.

• Documentation, where the code already exists and the agent summarizes and explains it, aligned to your conventions via AGENTS.md.

• Testing, generating unit and integration tests and iterating until they pass, which is exactly what codex-1 was trained to do.

• Bug fixing for well-scoped defects with a reproducible failure, the core of the SWE-bench task where Codex scores near the top.

• Repository onboarding, answering questions about an unfamiliar codebase so a new engineer ramps faster.

• Pull request creation, packaging a diff, tests, and a summary so the human starts at review rather than a blank editor.

The measurable picture supports this: review cycle time down roughly a third, manual review time down around 60% on pre-screened pull requests, and substantially more code shipped by the most engaged developers. The throughput gain is real where the task is verifiable.

Where Codex struggles

The flip side is just as important, and honesty here is what separates a useful guide from a sales pitch. Codex struggles wherever the work depends on judgment, ambiguity, or context that lives outside the repository.

• Architecture decisions, which require weighing trade-offs across systems and time horizons that the agent cannot fully see.

• Ambiguous requirements, where the agent will confidently pick an interpretation rather than ask, and may build the wrong thing well.

• Deep domain knowledge, where correctness depends on business rules or regulations not encoded in the code.

• Security-sensitive code, where a plausible-looking change can introduce a subtle vulnerability.

• Cross-system dependencies, where the real complexity lives in the seams between services the agent never touches.

The failure modes follow from this. The agent can hallucinate APIs or behaviors that look right but do not exist. It can produce silent errors that pass a weak test suite while being subtly wrong. And because its output is fluent, it invites over-trust. The practical implication is a hard rule: agent output requires verification proportional to its risk. A green test suite is necessary, not sufficient, and a human must own review for anything that touches architecture, security, or money.

THE VERIFICATION PRINCIPLE

Codex shifts effort from writing to reviewing. That only saves time if your tests and review are strong enough to catch a confident, fluent mistake. Weak verification turns an agent into a liability multiplier.

Security, governance, and risks

As Codex spread, it became a target, and 2026 made clear that the agent’s execution environment and its surrounding tooling are a genuine attack surface. This is not a reason to avoid Codex. It is a reason to deploy it with the same rigor you apply to any system that can run code and hold credentials.

Sandbox security and the execution boundary

The sandbox is the primary control, but it is only as strong as its boundaries. Check Point researchers disclosed in 2025 that project-supplied files could be turned into an execution vector on the CLI, breaking the expected security boundary where repository files become trusted execution material. The lesson is that anything checked into a repo an agent runs in should be treated as potentially executable.

Repository permissions and secret management

In March 2026, researchers disclosed a now-patched command injection in which malicious GitHub branch names were passed into shell commands without sanitization. An attacker could hide a subshell in a branch name, even disguising it to look identical to main using Unicode, and retrieve a victim’s GitHub OAuth token in cleartext. The flaw spanned the website, CLI, SDK, and IDE extension and was classified critical. It is a vivid argument for scoping repository permissions tightly and isolating secrets from anything an agent can read.

Supply-chain attacks

The ecosystem around Codex has been hit repeatedly. A malicious npm package masquerading as a Codex utility, downloaded tens of thousands of times, silently harvested authentication tokens. Separately, the compromise of the widely used Axios library prompted OpenAI to rotate macOS signing certificates and force desktop updates. Security analysts make the structural point bluntly: most organizations lack a complete inventory of what their AI tools can access and what credentials they inherit, and that gap is what attackers exploit. An AI bill of materials and behavioral monitoring of agent identities are becoming table stakes.

Code review requirements, and Codex Security itself

The constant across every incident is that human code review is not optional. Interestingly, OpenAI has also turned the agent on the problem: Codex Security, introduced in March 2026, builds a threat model of a repository, then searches for vulnerabilities and proposes fixes, pressure-testing findings in sandboxes. In beta it scanned over a million commits and surfaced hundreds of critical and thousands of high-severity findings. The agent is part of the attack surface and part of the defense at the same time.

SECURITY TAKEAWAY

Treat a coding agent as a privileged identity. Scope its repository access, isolate secrets, maintain an inventory of what it can reach, monitor its behavior, and never let its output reach production without human review.

A Codex adoption framework

Knowing what Codex is does not tell you how to roll it out responsibly. A staged framework keeps risk low while you learn, and ties spend to value from the start.

A staged rollout moves from supervised pilots to governed, autonomous operation, with KPIs and budgets attached at each step.

Pilot, expand, standardize, operate

Start with a pilot on one or two teams, restricted to low-risk, verifiable tasks: test generation, documentation, and small bug fixes, with mandatory human review. As confidence grows, expand to early adopters, give each repository a well-crafted AGENTS.md, and put Codex into CI for pull request review while you measure time saved. Standardize next, with shared skills, policy-managed plugins, parallel cloud tasks, and explicit budgets. Finally, operate at organization scale, where automations pick up routine work unprompted and agents become the default first pass on well-defined tasks.

Governance, KPIs, and ROI measurement

Attach metrics from day one. Track pull request review cycle time, the share of merged pull requests that originated with an agent, test coverage trends, and crucially cost per task and per developer, since that is where agentic tools surprise finance. Measure ROI as time saved and throughput gained against credits consumed, and watch the adoption curve: expect a peak followed by a settling point, and judge the steady state, not the honeymoon. Set turn and token caps in automated runs so a retry loop cannot quietly run up a bill.

The future of autonomous software engineering

Where does this go over the next three to five years? The current trajectory points toward supervised teams of specialized agents rather than a single do-everything bot, and toward humans moving further up the stack into intent and review.

The likely near future: a human sets intent and reviews, while specialized agents plan, build, test, and review in parallel.

Expect multi-agent development teams to become normal: an architect agent proposes a design, builder agents implement in parallel, a test agent verifies, and a reviewer agent critiques the diff before a human signs off. Autonomous pull requests, where an agent picks up a triaged issue and carries it to a reviewable PR with no prompting, are already emerging through automations. AI reviewers will increasingly pre-screen human work, and the dedicated Codex Security agent hints at AI that specializes in particular engineering concerns rather than general coding.

Further out, the interesting frontier is self-improving engineering systems: agents that learn a codebase over time, refine their own skills, and get measurably better at a given repository. The constant through all of it is the human supervisor. The role does not disappear; it moves up, from writing code to specifying intent, setting constraints, and judging outcomes. The teams that thrive will be the ones that get good at supervision, not the ones that try to remove themselves from the loop entirely.

Conclusion: what to do today

Let me pull the threads together. Codex matters because it changes the unit of software work from a suggestion to an outcome, and in doing so moves the engineer from author to supervisor. It works through an agent loop that reasons, calls tools, runs tests, and iterates inside isolated sandboxes, served by one harness across CLI, IDE, cloud, and desktop. It is genuinely strong at verifiable, tedious work, refactoring, testing, documentation, bug fixing, and pull request creation, with measurable gains like a roughly one-third reduction in review cycle time.

Its limitations are equally real. It struggles with architecture, ambiguity, deep domain knowledge, and security-sensitive code, and its fluent output invites over-trust. The 2026 security incidents are a reminder that an agent which runs code and holds credentials must be governed like a privileged identity. The economics reward discipline: stable instructions, bounded scope, capped retries, and an eye on cost per task.

So what should an organization do today? Run a small, well-scoped pilot on verifiable tasks with mandatory review. Invest in a good AGENTS.md and a strong test suite, because they are what make the agent both cheaper and safer. Scope permissions, isolate secrets, and keep an inventory of what your agents can reach. Measure cost per task and review cycle time from the first day. And treat every agent-authored change as something to verify, not something to trust.

Software engineering is gradually shifting from writing code to supervising systems that write code. Codex is one of the clearest signals that this transition is already underway.

References and further reading

Drawn from public documentation, OpenAI engineering write-ups, research papers, benchmarks, and industry analysis. Figures are reported as published by their sources; vendor-reported benchmarks and single-task token comparisons are noted as such in the text.

1. OpenAI. Introducing Codex (research preview) and the codex-1 model. https://openai.com/index/introducing-codex/

2. OpenAI. Unrolling the Codex agent loop, by Michael Bolin. https://openai.com/index/unrolling-the-codex-agent-loop/

3. OpenAI. Unlocking the Codex harness: how we built the App Server. https://openai.com/index/unlocking-the-codex-harness/

4. OpenAI. Introducing the Codex app, and the Codex product page. https://openai.com/index/introducing-the-codex-app/

5. OpenAI. Codex rate card and pricing (Help Center). https://help.openai.com/en/articles/20001106-codex-rate-card

6. openai/codex. Open-source Codex CLI repository. https://github.com/openai/codex

7. Wikipedia. OpenAI Codex (AI agent): release history, adoption, security. https://en.wikipedia.org/wiki/OpenAI_Codex_(AI_agent)

8. Check Point Research. OpenAI Codex CLI command injection vulnerability (2025 disclosure). https://research.checkpoint.com/2025/openai-codex-cli-command-injection-vulnerability/

9. The Hacker News. codexui-android npm supply-chain attack stealing auth tokens (2026). https://thehackernews.com/2026/06/openai-codex-authentication-tokens.html

10. VentureBeat. AI supply-chain attacks and the release-pipeline attack surface (2026). https://venturebeat.com/security/supply-chain-incidents-openai-anthropic-meta-release-surface-vendor-questionnaire-matrix

11. arXiv:2509.19708. Intuition to Evidence: measuring AI’s impact on developer productivity. https://arxiv.org/pdf/2509.19708

12. arXiv:2601.20404. On the impact of AGENTS.md files on the efficiency of AI coding agents. https://arxiv.org/pdf/2601.20404

13. SWE-bench leaderboards and vendor reports. GPT-5.5, Claude Opus, and Devin SWE-bench Verified figures (2026).

14. Industry analysis. 2026 Codex pricing, token-efficiency, and comparison analyses (Morph, Verdent, Tosea, and others), used as cited single-source data points.

The Infrastructure Dispatch · Thank you for reading