The software industry has a habit of naming useful patterns in the least usable way possible. A new shape appears, teams start building with it, and then the default name arrives sounding like it was pulled from a conference abstract.

In AI agent work, one of those names is agentic harness. The phrase is not wrong. It describes a structured environment for running, guiding, testing, evaluating, and constraining an AI agent. But it is heavy. It is awkward in a repository name, awkward in a standup, and awkward when a product team asks what the thing actually does.

We have a better word available: rig.

The pattern needs a human name.

Agentic harness is precise in the way many early technical terms are precise. It points at the right boundary, but it asks too much of the listener.

Agentic still needs translation for many people. It gestures at systems that can reason, choose tools, pursue a goal, and operate with some autonomy. That matters, but the word often puts a glossary between the speaker and the work.

Harness is also useful. It suggests safety, control, and structure around something that could otherwise move too freely. In AI development, that metaphor fits.

The problem is the combination. Agentic harness sounds larger and more formal than most of these systems are. A developer can name a repository contract-agentic-harness, and the meaning is technically defensible. But the name gets in the way. 

contract-agentic-harness
contract-rig

The second name is shorter, clearer, easier to say, and easier to reuse. That matters more than it sounds like it should.

A rig is the setup.

A rig is a collection of parts arranged so something can work. The word already belongs to builders. We use it in phrases like test rig, dev rig, camera rig, drilling rig, and simulation rig.

A rig does not promise elegance. It does not imply a platform, a framework, or a finished product. It says, plainly: this is the assembled system that lets us run the thing.

That maps cleanly to agent work. An AI agent rarely operates by itself. It needs a surrounding setup:

  • Instructions and task boundaries.
  • Tools, permissions, and schemas.
  • Memory, retrieval, and source handling.
  • Policies, guardrails, and human review.
  • Evaluations, logs, fallbacks, and deployment scripts.

That surrounding setup is the rig. The agent acts. The rig makes the action usable.

The agent is not the product.

This is the part worth driving home. A useful agent system is not just a model with a prompt. It is the operating environment around the model. 

agent + tools + controls + evals + runtime = rig

The model can draft, search, classify, plan, or patch code. But the system becomes trustworthy only when the surrounding pieces make that work repeatable, inspectable, and correctable.

A contract agent is interesting. A contract-rig is operational. It can define the contract types it accepts, the clauses it checks, the citations it must return, the review path for risky recommendations, and the tests that prevent quiet regressions.

A research agent is interesting. A research-rig is useful. It can limit sources, track claims, preserve citations, mark uncertainty, and keep a human in the loop when the answer will be used for a real decision.

A coding agent is interesting. A coding-rig is what makes the work reviewable. It gives the agent repository context, test execution, patch creation, linting, diff review, and a clear place to stop.

Rigs scale as a vocabulary.

Good technical terms are usually boring. They are compact enough to survive everyday use. We say server, worker, runner, router, queue, job, task, pipe, and hook because those words are useful under pressure.

Rig can do the same job for practical agent setups: 

contract-rig
invoice-rig
research-rig
support-rig
coding-rig

It also composes cleanly when the use case needs more precision: 

contract-eval-rig
research-eval-rig
support-tool-rig
browser-rig
crm-rig
repo-rig

Internal platforms can use the same vocabulary without making every repository name feel like a dissertation: 

agent-rig
rig-core
rig-runtime
rig-kit

The meaning holds. The language gets lighter.

The word keeps us honest.

There is another advantage: rig sounds practical.

AI language often makes systems sound more autonomous, complete, or intelligent than they are. Agentic can be accurate, but it can also lend a system sophistication it has not earned yet.

Rig does the opposite. It reminds everyone that the work is an engineered setup. It may be temporary. It may be messy. It needs tests. It needs maintenance. It has parts that can fail.

That framing is healthier for developers, stakeholders, and users. An agent rig is not a mysterious intelligence layer. It is a structured environment where an AI model can do useful work under defined conditions.

What belongs in a rig.

A rig should usually include more than a prompt. A single prompt is a prompt. A single tool wrapper is a tool. A single agent definition is an agent.

A rig is the runnable system around the agent. It is the thing a team can run, inspect, test, and improve.

  • Agent instructions and task boundaries.
  • Tool definitions and permission rules.
  • Runtime configuration and workflow logic.
  • Input and output schemas.
  • Test cases, evaluations, and fixtures.
  • Logging, traces, and failure handling.
  • Guardrails, review queues, and approval steps.
  • Deployment and maintenance scripts.

If the system is ready to run a real workflow, it is probably a rig. If it is only a component inside that workflow, call it by the smaller name.

The proposal.

Use rig as the default everyday term for practical agent setups.

Not as a formal standard. Not as a replacement for runtime, eval, workflow, tool, graph, memory, or model. Those words still matter when they name a specific part of the system.

Rig is the word for the assembled thing.

This is the rig that runs the agent.

That sentence is enough. It is concrete. It is teachable. It does not overclaim. It gives teams a short name for the work they are actually doing.

The industry does not need every AI concept to sound bigger than it is. Sometimes the better name is the one that gets out of the way.

We do not need more agentic harnesses. We need better rigs.