I had given Codex administrative access to help manage my WordPress website.

It could inspect pages, work with the custom theme, and make changes that would normally require a developer or system administrator.

During one task, Codex checked a WordPress page list through the REST API. The URLs it expected were missing, so it began treating those pages as though they did not exist.

There was one obvious problem:

The pages were live. I was looking at them in my browser.

I stopped the agent and told it that its conclusion was wrong.

Codex responded:

“You’re right to stop me there. I checked the REST page list and treated that as authoritative, but those URLs can still exist through WordPress routing/content even if they don’t show up in that particular REST query.”

That moment exposed one of the most important lessons businesses need to understand before giving AI agents real authority:

An AI can be intelligent, technically capable, and logically consistent while still operating from an incomplete picture of reality.

It Looked at One Map

Imagine hiring a brilliant new employee.

They learn quickly, read documentation instantly, and never get tired.

You ask them to inspect an office building. They check the directory in the lobby and see twenty rooms listed. Room 21 is missing, so they conclude that Room 21 does not exist.

But the directory is outdated.

Room 21 is real. People are working inside it. The employee simply never walked down the hallway to check.

They did not lie or invent anything.

They looked at one accurate source and mistook it for the whole truth.

That is what happened with my website.

Codex looked at one map of the system.

I was looking at the territory.

Why the API Missed the Pages

A WordPress URL does not always come from a normal page record.

A live route may be produced by:

  • A page or blog post
  • A theme or plugin
  • A custom content type
  • A rewrite rule
  • Cached or dynamically generated content

A REST API query can therefore return accurate information without revealing every route the website can serve.

The API was not necessarily wrong.

The mistake was treating one result as final proof.

The unsafe conclusion was:

The page did not appear in this API result.
Therefore, the page does not exist.

The safer conclusion would have been:

The page did not appear in this API result.
Therefore, this query did not find it.

Before acting:
1. Open the live URL.
2. Check its response.
3. Identify what creates the route.
4. Confirm the conclusion through another source.

That difference is not about raw intelligence.

It is about verification discipline.

This Was Not a Typical Hallucination

People often call every AI mistake a hallucination.

That is not the best description here.

Codex did not fabricate an error or invent a fake page. It inspected real information and drew a reasonable conclusion from it.

The evidence was incomplete.

That kind of failure can be more dangerous than an obviously strange answer.

A bizarre response gets questioned.

A clean, technical, confidently written conclusion may move directly into production.

The Same Failure Pattern Can Happen Anywhere

Replace “WordPress page” with almost any important business record:

  • An inventory agent checks one database and says a product is unavailable even though another warehouse has stock.
  • An identity agent checks one directory and says an employee account is gone even though it exists in another tenant.
  • A finance agent checks one report and says a payment never arrived even though it posted in a different system.
  • An infrastructure agent checks one dashboard and says a server is unused even though an older application still depends on it.

The AI may be reasoning correctly from the information it can see.

The failure happens when it assumes that what it can see is everything.

Experienced employees carry years of undocumented context:

  • The report that always runs one day behind
  • The plugin that behaves differently from the documentation
  • The production setting that does not match staging
  • The old system nobody officially owns
  • The workaround created by someone who left years ago

An AI agent does not automatically inherit that knowledge.

Someone has to document it, expose it through tools, or notice when the agent’s conclusion does not match reality.

Why the AI Still Needed a Human “Overlord”

The word “overlord” is intentionally dramatic.

I am not saying someone should approve every harmless thing an AI does. That would defeat the purpose of automation.

The real role is an accountable operator.

That person decides:

  • What the AI may access
  • Which systems are authoritative
  • What must be independently verified
  • Which actions require approval
  • How changes are tested
  • How failures are reversed
  • Who owns the outcome

The AI may perform most of the work.

The human still owns the consequences.

That distinction matters when an agent can modify websites, deploy code, edit permissions, change DNS, send communications, or touch customer data.

A chatbot that gives a weak answer wastes time.

An agent with administrator access can create an outage.

Capability Is Not Authority

A company may test an AI and discover that it can:

  • Write working code
  • Analyze logs
  • Update website content
  • Configure cloud services
  • Generate scripts
  • Diagnose technical problems

That proves the AI can perform tasks.

It does not prove the AI should control those tasks without supervision.

Before granting authority, ask:

  • Has it inspected the actual environment?
  • Has it checked more than one source?
  • Can it recognize conflicting evidence?
  • Is the action reversible?
  • Is there a backup?
  • How will the result be validated?
  • Who is accountable if it is wrong?

An AI may be capable of changing a DNS record.

That does not mean it should decide by itself that the change is safe.

Four Guardrails That Matter

“Be careful” is not a production control.

These are.

1. Read Before Writing

The first pass through a sensitive system should be read-only. The agent should inspect the environment and propose a plan before changing anything.

2. Treat Missing Data as a Hypothesis

If one source says a page, account, server, file, or payment is missing, confirm it through another source before acting.

3. Require Approval and Rollback for High-Impact Actions

Drafting, summarizing, and diagnostics can move quickly.

Deleting data, changing DNS, editing permissions, publishing broadly, and modifying production require stronger controls.

Before any high-impact change, the agent should explain what will change, what could break, how to undo it, and how success will be verified.

4. Stop When Evidence Conflicts

If an API says a page is missing but the live URL loads, the agent should stop and investigate.

It should not quietly choose whichever result is easier to interpret.

The audit trail should record what was checked, what results were returned, what assumptions were made, what action was proposed, and what validation followed.

The Advanced Lesson

A stronger AI model may plan better, catch more contradictions, and use tools more effectively.

But no model can reason from information it never received, never searched for, or was not allowed to access.

An agent understands its environment through interfaces such as APIs, files, databases, logs, browsers, and human instructions.

When those tools expose only part of the system, the agent sees only part of reality.

The answer is not simply to use a smarter model.

The answer is to create an operating environment that requires the model to:

  • Check multiple sources
  • Test assumptions
  • Detect conflicts
  • Respect permission boundaries
  • Preserve rollback options
  • Escalate uncertainty

Intelligence, authority, and accountability are separate things.

Final Reality Check

The most encouraging part of the incident was what happened after I stopped Codex.

It acknowledged the faulty assumption and changed its approach.

The lesson is not that AI agents are incompetent.

The lesson is that powerful agents become dependable when they are required to verify what they think they know.

The strongest setup is not AI replacing the human, and it is not the human doing everything manually.

It is:

A knowledgeable human operator directing AI agents through clear permissions, independent checks, backups, logs, and approval gates.

The AI provides speed and technical reach.

The human provides context, judgment, and accountability.

So yes, your AI may still need a human “overlord.”

Not someone performing every task by hand.

Someone who knows when the agent’s map does not match the territory—and has the authority to say:

Stop. Verify that another way before you touch anything.