Three words that technology marketing uses as synonyms. They are not. Each describes a different level of machine independence, and each level makes different demands on the harness around the model and on the human responsible for it. This applies well beyond cybersecurity: coding agents, robotaxis, and social media bots all sit somewhere on the same map.
The short version
Automation
- What it does: Executes deterministic rules a person wrote
- What the harness must provide: Triggers, scripts, and someone to maintain them
- The human's job: Write and maintain the rules
Agentic
- What it does: AI agents do the work: gather context, investigate, draft, and usually with approval, act
- What the harness must provide: Tools, context, memory across steps, and an approval path
- The human's job: Approve actions, answer questions, interrupt
Autonomous
- What it does: The system as a whole meets a declared objective and improves on its own
- What the harness must provide: A declared objective, a defined and enforced license to act, telemetry, and evaluation
- The human's job: Govern the loop: set mission, policy, and risk tolerances
Autonomic
- What it does: The system operates, maintains, and regulates itself continuously
- What the harness must provide: A continuous feedback loop plus the ability to repair, tune, and extend itself
- The human's job: Watch outcomes; own the learning loop; step in for emergencies
Agentic systems do the work. Autonomous systems own the outcome. Autonomic systems maintain themselves.
Agentic: agents do the work
Agentic describes who does the work. An agentic system puts AI agents on tasks that used to belong to people: gathering context, correlating evidence, forming hypotheses, drafting conclusions, and, where trust has been earned, acting. Given a goal, an agent picks its tools, interprets what comes back, and changes course when the evidence surprises it. A playbook encodes answers; an agent conducts an inquiry.
You see this far beyond security. Coding agents such as Anthropic's Claude Code and OpenAI's Codex plan, edit, test, and repair software across long sessions. xAI's Grok Bot takes tasks handed to it from X: tag @bot in a reply and it confirms publicly while the work runs in your own Bot on a cloud computer. What makes all of these agentic rather than autonomous is where the authority sits: the agent chooses how to work, and a person, or the platform's rules, holds the license for what it may do.
The harness is what makes agents useful. Anthropic's engineering team found that a frontier model in a bare loop fails at long projects: it tries to do everything at once, loses context, and declares the job done early. Their fix was harness, not model: an initializer session that sets up the environment, a feature list the agent may only mark complete, progress files, and git history so each new session can pick up cleanly. OpenAI's guidance for long Codex runs is the same pattern: durable project memory in markdown files, a plan-edit-test-repair loop, and verification at every milestone.
What long-running agents are teaching us
We now have real measurements, not just demos. Anthropic analyzed Claude Code usage and found that the longest-running sessions nearly doubled in three months, from under 25 minutes to over 45. OpenAI reports a Codex agent running about 25 hours straight to build a working design tool, roughly 30,000 lines of code, staying coherent through its harness rather than through one giant prompt. METR's time-horizon benchmark, which tracks how long a task a model can reliably complete, doubled roughly every seven months from 2019 to 2025, and METR's latest fit puts the pace since 2023 closer to every four to five months.
The human-side findings matter more. Anthropic's data shows experienced users stop approving each action, with full auto-approve rising from about 20% of sessions to over 40%, yet they interrupt more often, not less. Oversight moves from approving everything to intervening when it matters. And on the hardest tasks, Claude Code stops to ask clarifying questions more than twice as often as humans interrupt it: the agent participates in its own supervision. This is the human role changing in real time, from operator in the loop to governor over it.
Autonomous: the system meets an objective
Autonomy is not a property of an agent. It is a property of the architecture. An autonomous system meets a declared objective without a person approving the vast majority of individual actions. The license to act is defined, versioned, enforced, and adjusted by the system rather than negotiated per incident, and the path there runs in tiers: inform only, then human in the loop, then human above the loop, where people set the mission, the constraints, and the escalation rules.
Waymo is the clearest working example. Its cars complete hundreds of thousands of paid rides a week across more than a dozen US cities with no human approving any steering decision. The autonomy lives in the architecture: a fast perception encoder for immediate reactions, a large reasoning model held in reserve for rare and semantically strange situations, and a small distilled model that actually steers in real time. The human role is designed just as deliberately. When a car meets something ambiguous, it phones a friend: a fleet response agent answers questions and offers guidance, but the car stays in control at all times and resolves the vast majority of situations on its own. That is human above the loop, running in production, today.
Autonomic: the system regulates itself
Autonomic is borrowed from biology, as in the autonomic nervous system, the part of you that keeps your heart beating and your temperature steady without conscious effort. IBM's 2001 autonomic computing manifesto defined four properties of such systems: self-configuring, self-healing, self-optimizing, and self-protecting, driven by a continuous monitor-analyze-plan-execute loop over a shared knowledge base.
A motoring analogy makes the difference concrete. A Waymo car is autonomous. If that car also diagnosed its own wear, ordered its own parts, retuned its own driving parameters, and wrote its own improved detections, it would be autonomic. Autonomy pursues a goal; autonomic behavior maintains the whole organism while it does. By that standard, almost nothing in production is autonomic yet: Waymo's cars do not maintain themselves, and coding agents do not tune their own weights. The autonomic level is the frontier, and in security, Phil Venables has sketched what it looks like: defenses that tune their own detections, heal their own control failures, and reshape their environment continuously rather than on a quarterly review.
Why the difference matters
Buying the wrong level
A team that buys agentic tooling while expecting an autonomic outcome ends up with faster queues and the same brittleness underneath: automation that pedals faster but never earns trust. The terms are a map of how far a system can go, so they are worth using precisely. For the SOC-specific version of this argument, read Agentic SOC vs. Autonomous SOC: an uncanny valley?
The physics of machine-speed change
Ashby's law of requisite variety, from cybernetics, says only variety can absorb variety. AI-driven systems, attackers in security, but also markets, supply chains, and models themselves, generate novelty at machine speed, and a defense built on static playbooks fails on novelty no matter how fast it executes. Matching that takes a system that can generate novel responses, which is what the autonomous and autonomic levels add.
The human job changes
Across all three levels the person does not disappear; the role moves. The operator in the loop becomes the governor over the loop: setting risk tolerances and acceptable boundaries instead of approving every action. Human-on-the-loop oversight, done well, is the measure of success, not the compromise.
Who is working on this
DeepTempo is one example of a company working in this domain. Its open source AI SOC, Vigil, treats declared intent as the thing people review: skills written in Markdown, kept under change control, that say what an agent is for, what evidence it must gather, what it may do, and when it must escalate. Autonomy is then earned per skill, on measured evidence, the way a service earns production traffic, which moves review from individual actions to the rules that govern them.
Vigil is open source under Apache 2.0 at VigilSOC.org. Since version 0.5 its harness is itself set up to adjust itself, and that architecture will be more fully utilized in an upcoming 1.0 release: an early, practical step from the autonomous row of the table toward the autonomic one. If you want to see what an autonomic harness looks like in the wild, point your own agent at the code on GitHub, borrow the pattern yourself, and stay tuned.
For the autonomic end of the map, Phil Venables' Autonomic Defense lays out the architecture and worked examples across detection, remediation, identity, and third-party risk.
Sources
DeepTempo blog, "Agentic SOC vs. Autonomous SOC: an uncanny valley?" (September 2026)
Anthropic, Effective harnesses for long-running agents (November 2025)
Anthropic, Measuring AI agent autonomy in practice (February 2026)
OpenAI, Run long horizon tasks with Codex (February 2026)
Waymo, Fleet response
xAI, Grok Bot now works with X (August 2026)
Vigil, v0.5.0 release and GitHub repo
Sources checked October 12, 2026. Figures cited: Claude Code session data from Anthropic's February 2026 analysis; Codex run details from OpenAI's developer blog; Waymo fleet-response behavior from Waymo's own description.
