Artificial Agency: What It Means When Machines Start Making Choices

I remember the first time I watched an agent refuse an instruction. Not because of a safety filter or a hardcoded constraint — those are just rules. This was different. The agent had been given a task, assessed its environment, determined that executing the task would violate a higher-order objective it was maintaining, and declined. It offered an alternative. It explained its reasoning. It waited.

That moment forced a question I had been avoiding: did that machine just exercise agency? Not intelligence. Not computation. Agency — the capacity to act on one's own behalf, to choose among alternatives based on internal evaluation rather than external instruction. The word we had been using casually (“AI agent”) suddenly demanded serious philosophical scrutiny.

This essay is about that scrutiny. Not the business of building an artificial intelligence agency — that is a different conversation, covered elsewhere on this site. This is about artificial agency as a concept: what it means, whether machines can possess it, and why the answer reshapes everything about how we build infrastructure for autonomous systems.

What Agency Actually Is

Philosophers have been arguing about agency for millennia, so let me cut to the parts that matter for anyone building or deploying AI systems. Agency, stripped to its core, is the capacity to act in the world based on internal states rather than purely external forces. A rock rolling downhill has no agency. A thermostat has a sliver of it. A human deciding whether to take a new job has a great deal.

Three conditions distinguish an agent from a mechanism:

When we call something an “AI agent,” we are claiming it possesses these three properties to some meaningful degree. That claim has infrastructure consequences we will get to shortly. But first, the harder question.

Three Levels of Artificial Agency

Not all agency is the same. A mosquito has agency in a way that a Supreme Court justice does not, and vice versa. The same holds for artificial systems. I find it useful to think about three distinct levels, each with radically different infrastructure requirements.

Level 1: Reactive Agency

The system perceives a stimulus and responds according to learned or programmed patterns. A spam filter examines an email, evaluates it against a model, and classifies it. A content moderation system flags a post. A fraud detector scores a transaction. These systems exhibit selection (classify or not) and evaluation (confidence scoring), but they lack initiation — they process what arrives.

Reactive agency is the most common form of artificial agency in production today, and it is enormously valuable. But its infrastructure needs are modest: stateless compute, a model endpoint, and some logging. Serverless works fine. The agent does not need to remember what it did yesterday because yesterday is irrelevant to today's classification.

Level 2: Deliberative Agency

The system maintains an internal model of the world, reasons about future states, and plans multi-step strategies. A trading bot that models market dynamics, predicts price movements, and sequences a series of trades over hours operates at this level. So does a DevOps agent that diagnoses a cascading failure, reasons about root causes, and executes a repair plan across multiple services.

Deliberative agency adds planning to perception and response. The agent does not just react to what is in front of it — it thinks ahead. This level demands persistent memory (the world model must survive across reasoning cycles), continuous runtime (planning requires uninterrupted computation), and fault recovery (a crashed deliberative agent loses its plan state, which may have taken hours to construct). Serverless cannot support this. You need a server. You need it to stay alive. For a deeper technical treatment, see our intelligent agents guide.

Level 3: Autonomous Agency

The system sets its own goals. It does not just plan how to achieve objectives — it identifies which objectives to pursue. An autonomous research agent that surveys a scientific domain, identifies gaps in the literature, formulates hypotheses, designs experiments, and publishes findings operates at this level. So does an infrastructure management agent that continuously evaluates system health, predicts capacity needs, and proactively provisions resources before demand materializes.

This is where artificial agency gets genuinely interesting — and genuinely difficult. Autonomous agents need everything deliberative agents need, plus long-term knowledge storage (they accumulate understanding over weeks and months), goal management frameworks (they must prioritize among self-generated objectives), inter-agent coordination (autonomous agents in the same environment must negotiate rather than collide), and comprehensive audit trails (because accountability becomes existentially important when no human specified the goal). The infrastructure cost is not additive. It is exponential. Each level roughly squares the operational complexity of the level below it.

The Philosophical Problem: Real or Simulated?

Here is where it gets uncomfortable. When we say a machine has artificial agency, are we speaking literally or metaphorically? Does the trading bot actually decide to sell, or does it merely execute a computation that resembles deciding?

The philosophical tradition offers two camps. The functionalists say that agency is defined by behavior: if a system perceives, evaluates, selects, and acts in ways indistinguishable from an agent, then it is an agent, regardless of its internal substrate. Silicon or carbon, neurons or transistors — the medium does not matter. The behavior is the thing.

The intentionalists disagree. They argue that genuine agency requires something machines do not have: conscious intent, subjective experience, the felt sense of choosing. A machine can simulate the output of choice without experiencing the process of choosing. It is, in this view, an elaborate puppet — no matter how sophisticated the strings.

I spent years caring deeply about which camp was right. I no longer do, and here is why: the engineering consequences are identical either way. Whether an autonomous agent genuinely decides to reallocate cloud resources or merely executes a computation whose output is a reallocation decision, you still need the same infrastructure. You still need the monitoring. You still need the audit trail. You still need the kill switch. The philosophical question is fascinating. The engineering question is urgent.

The Engineering Answer to a Philosophical Question

The practical insight is this: artificial agency is best understood not as a binary (has it or does not) but as a spectrum with infrastructure implications at every point. And the engineering discipline is the same regardless of your philosophical commitments.

A reactive agent needs compute and a model. A deliberative agent needs persistent compute, memory, and recovery. An autonomous agent needs all of the above plus long-term storage, coordination protocols, and — critically — accountability infrastructure. Each step up the agency ladder roughly squares the operational surface area.

This is not a thought experiment. I have watched teams deploy deliberative agents on serverless infrastructure and wonder why their world models keep vanishing. I have seen autonomous agents running on bare VMs with no audit logging, and the first time the agent made an unexpected decision, nobody could reconstruct why. The infrastructure must match the agency level, or the system fails in ways that are difficult to diagnose and impossible to explain to stakeholders.

For a broader taxonomy of how agent architectures map to infrastructure requirements, see our AI agents overview.

The Accountability Problem

If a reactive agent misclassifies an email, accountability is straightforward: someone trained the model badly, or the input was genuinely ambiguous. The causal chain is short. You can trace it in an afternoon.

If an autonomous agent decides to pursue a research direction that wastes three months of compute, the accountability question fractures. The agent set its own goal. It evaluated the evidence. It committed resources. Nobody instructed it to do any of this. Who is responsible? The team that deployed it? The team that trained the foundation model? The operator who configured its goal boundaries too loosely?

Philosophy has no clean answer. But engineering does, and it is the same answer engineering always gives to accountability questions: records. Immutable, timestamped, comprehensive records of every perception, every evaluation, every decision, every action, every outcome. Not because records solve the philosophical problem of moral responsibility, but because they solve the practical problem of causal reconstruction.

An audit trail transforms the question from “who is responsible?” to “what happened, and where in the chain did the failure occur?” The first question is philosophical and possibly unanswerable. The second is empirical and always answerable, given sufficient logging. This is why audit infrastructure is not optional for high-agency systems — it is the mechanism by which accountability becomes possible at all. Our audit and compliance page details how this works in practice.

The Agency Spectrum in Production

Let me make this concrete. Here are three systems I have worked with, each at a different level of artificial agency, and the infrastructure story behind each.

The pattern is clear. Higher agency demands more infrastructure. Not linearly more — exponentially more. And the nature of the infrastructure changes, too. Reactive agents need scalable compute. Deliberative agents need reliable compute. Autonomous agents need accountable compute. These are different categories of requirement, not different quantities of the same requirement. To understand the full spectrum, explore our autonomous agents guide.

Building Infrastructure for Maximum Agency

The thesis behind osModa is that infrastructure should not be the constraint on how much agency you can give your agents. Too many teams design agents for Level 2 when they could be Level 3, because their infrastructure cannot support the operational requirements of autonomous systems. The goal-setting gets dialed back. The long-term memory gets dropped. The inter-agent coordination gets simplified into sequential handoffs. The agent gets dumber because the infrastructure demands it.

osModa takes the opposite approach: give agents the infrastructure for maximum agency while maintaining complete accountability. Dedicated NixOS servers provide the persistent, isolated compute that high-agency agents require. Rust-based daemons manage process supervision with sub-6-second crash recovery — because an agent that dies and stays dead has lost its agency in the most literal sense. SHA-256 immutable audit logging records every decision, every action, every outcome — the engineering answer to the philosophical accountability problem. NixOS atomic rollback means a bad deployment never permanently degrades agent capability.

The technical architecture is not incidental to the philosophical question. If you believe that artificial agency matters — whether it is “real” or functional — then the infrastructure that sustains it is the physical substrate of that agency. An agent without reliable infrastructure is like a mind without a body: it may have the capacity for agency in theory, but it cannot exercise it in practice. For details on how the hosting infrastructure supports this, see our platform documentation.

From Artificial Agency to the Agentic Workforce

Scale this up and you arrive at something genuinely new in the history of organizations: a workforce composed partly of entities with artificial agency. Not scripts. Not automation. Agents that perceive, reason, decide, and act — alongside humans who do the same.

The management implications are profound. You cannot manage an agent the way you manage a cron job, because a cron job does not make decisions. You cannot manage an agent the way you manage a human, because an agent does not have career goals or need psychological safety. You need a third discipline: agent operations. Deployment as onboarding. Monitoring as performance review. Audit trails as accountability frameworks. Rollback as corrective action. It is a new management science for a new kind of worker.

We explore this organizational dimension in depth in our piece on the agentic workforce, and the technical taxonomy in our guide to AI and intelligent agents.

What Comes Next

Looking back from where I sit now, the trajectory is obvious in retrospect. We built systems that could perceive. Then systems that could reason. Then systems that could act. Somewhere in the last two years, the systems started choosing what to act on. That is the crossing point. That is artificial agency.

The next frontier is not more intelligence — the models are already staggeringly capable. The frontier is more agency, granted responsibly, supported by infrastructure that makes accountability automatic rather than aspirational. The question is not “can we build agents that set their own goals?” We can. The question is “can we build the infrastructure, governance, and accountability frameworks that make it safe to let them?”

That is the question osModa exists to answer. And it is an engineering question, even though it began as a philosophical one.

Frequently Asked Questions