Why you shouldn't start with AI agents when processes aren't documented

The agent ask shows up before the process does.

Someone heard it from above. A board deck. A conference. A peer who “already has agents.” The room fills with language about automation, handoffs that run themselves, and work that disappears overnight.

Then someone asks a quieter question: which process, exactly, are we automating?

Often the answer is thin. The path still lives in one person’s head. The handoff still changes depending on who is in the room. There is no shared write-up of inputs, decisions, exceptions, or what “done” looks like when the expert is out.

That isn’t a tools gap. It’s enablement before agents: you can’t automate a process you haven’t documented.

Agents from above, foundations still missing

Agent hype inside mid-market teams often arrives as pressure, not as a named job.

Leadership wants the next wave. A few people already build private workarounds. Premium seats sit unused for agent practice because nobody knows when an agent would actually help. Meanwhile the everyday path that would need to be solid first (the report, the research step, the handoff, the documentation loop) still isn’t written down.

So the organization talks agents while the foundations stay soft: shared baseline, one owned workflow, clear guardrails, a keepable way of working. Loud agent language with weak workflow, owner, and clock is a recognition problem, not a build problem.

To expedite a process, you have to know the process.

Soft proof: the “no processes here” pattern

We keep seeing the same picture without needing a named account to make the point.

An IT or operations leader describes the org honestly: there aren’t really processes here, not in a form anyone else can run. Judgment lives in one person. Someone higher up already wants agents. The team chasing “I want that” is ahead of the team that can name one recurring path with inputs, exceptions, and a definition of done.

That is one problem, not a missing swarm. You don’t need an agent prototype first. You need foundations and one documented everyday workflow before agent language becomes an operating plan.

When is an agent premature?

An agent is premature when any of these are still true:

• Nobody can name the everyday job the agent would own.
• The path still depends on one person’s judgment with no write-up.
• Inputs, exceptions, and “done” change by who is in the room.
• The team has not practiced AI on that path with shared guardrails.
• Success criteria for a prototype are “we have agents,” not “this workflow works without the original expert.”

Agents belong on recurring, documented work. They do not invent the process. They scale a process that already exists in a form other people can follow.

If you cannot hand the path to a colleague and get a recognizable outcome, you do not have an agent opportunity yet. You have an enablement and documentation gap.

What must be documented first

Skip the agent stack until one path is named and written.

1. Name one recurring job. Not a catalog of agent ideas. One report, handoff, research step, or documentation loop someone already runs.
2. Write the path as it actually runs. Inputs, decisions, exceptions, review points, and what “good” looks like when the power user is out of the room.
3. Practice AI on that path first. Shared baseline, real materials, keepables the team owns. Foundations before automation.
4. Only then ask what an agent could own. Narrow scope. Clear kill criteria. Workflow and guardrails still visible, not a swarm theater piece.

That sequence protects the build later. It also protects the people who would otherwise be asked to automate fog.

What to do instead (document one path)

If agent language is loud and the process is still thin, do not start with a prototype farm.

Pick one everyday workflow. Document it. Demonstrate AI inside it. Leave a keepable the team owns. Support the first repetitions until more than one person can run the path.

That is enablement before agents. It is slower on the slide deck. It is faster when someone asks which process you automated, and you can point at something real.