All lessons › Function E — The Agentic SOC › Discover — the Sensors, and the Agent-Shaped Hole in Them
E1.0

Start here — the agentic SOC, and the stack that runs it

E1

This starts chapter E1. Its course guide is E1 in the Function E course guide →

▶
Lightboard recording

Not recorded yet. The lesson below is complete and runnable today — the video is added later without touching this page.

Video placeholderpublishes automatically from recordings/E1.0.mp4
Risk

A detection stack tuned for human tempo, watching an actor that acts a thousand times an hour and never repeats a session.

Control

Agent telemetry as a first-class data source, detections written for agent behaviour, and a stop lever that a human can actually pull in time.

The lab

Put one agent trace and one human session side by side and list what separates them.

◉Use case relevance

An hour of an agent is 1,400 actions across 260 resources in 96 sessions. An hour of a person is twelve actions. Every detection, baseline and playbook you own was tuned against the second number.

At CyberTravels. cybertravels/soc/__init__.py carries the incident clock, and its shape is the argument. elapsed_budget('contain') shows where the time actually goes: attribute is the largest block, and for a human actor it would be near zero. Every lesson in this function names a stage on that clock.

◴What this lesson is — Day 0, Day 1, Day 2

The SOC as one system with a clock, and the observation the whole function turns on: the estate's detection content was written for an actor that acts a few times a minute and is now watching one that acts a thousand times an hour. Including where the clock actually goes, which is establishing who acted.

Day 0 — why

A detection stack tuned for human tempo, watching an actor that acts a thousand times an hour, reports nothing and means nothing.

Day 1 — how

Learn the five intervals and the open-source stack that measures them, before building anything.

Day 2 — measure

The five intervals themselves — discover, detect, understand, contain, recover. Every later lesson moves one of them.

Measure this

what to measuredenominator or target
the five intervals themselvesdiscover, detect, understand, contain, recover — in minutes; every later lesson moves one
Who this function is for. Security operations. SOC analysts, detection engineers, incident responders, threat hunters and DFIR leads — running a SOC that now has agents in it, and agents watching it. What changes is the analyst's job: directing a loop instead of reading alerts one at a time.

▦The framework, and how it works

   one hour                person        agent
   actions                    12          1400
   distinct resources          5           260
   gap between calls        180s             2s
   sessions                    1            96

   chapter 8   detect it     chapter 9   respond to it
   +----------------------+  +-------------------------+
   | triage as a loop     |  | scope at machine speed  |
   | detections FOR agents|  | contain, replay, stop   |
   +----------------------+  +-------------------------+

CyberTravels has a SOC. It was built for people.

It watches for a login from an unusual country, a burst of failed authentications, an employee downloading the customer list on their last day. It is good at those, and none of them describes CyberTravels.

An agentic SOC watches a different actor. One hour of CyberTravels' Workflow Agent is roughly 1,400 tool calls across 260 resources in 96 sessions. One hour of Alex is twelve actions. Every threshold, baseline and playbook CyberTravels owns was tuned against the second number.

And the actor is not only the adversary. It is also the instrument: chapter E2 puts an agent on detection engineering and chapter E3 puts one on the alert queue. Both work, and both bring the same failure mode — a loop that concludes confidently can conclude wrongly at machine speed.

The unit this function is written in

A ratio of 117× is not a fact you can act on. The unit is an interval, and there are five of them between an agent doing something it should not and the control that stopped it being back at target:

intervalfromtochapter
discoverthe behaviour happenssomebody could see it at allE1
detectit is visiblean alert existsE2
understandthe alert existsa conclusion you can act onE3
containthe conclusionthe actor stoppedE4
recoverstoppedthe control measurably back at targetE5

Every lesson in this function shortens one of those five, or spends one deliberately to buy something else — and each says which, in a line under its own concept. The intervals are where the numbers live: CyberTravels' detection interval is 194 minutes against a 15-minute target, and its manual containment runbook finishes in 34 minutes against a measured breakout time of 29. Neither of those is an opinion about tooling.

The stack that runs it

Nothing in this function needs a product you do not have. Every phase below has a working open-source reference, and the lessons are written against these rather than against a vendor's diagram — so you can build the whole thing and find out what it does not cover, which is the part that matters.

phasewhat has to existopen source that does it
discoverendpoint and workload sensingWazuh (agent, manager, indexer)
cloud posture, on a scheduleProwler, ScoutSuite
container runtime and image contentsFalco, Trivy
sensitive content in motionregex plus Wazuh file integrity monitoring
agent traces — prompts, tools, decisionsOpenTelemetry, instrumented at the gateway
detectsomewhere for all of it to landOpenSearch (or the Wazuh indexer)
rules, portable and reviewableSigma, mapped to ATT&CK and ATLAS
deception with no thresholdcanary tokens and honeypot tasks you write
understandthird-party intelligenceMISP, OpenCTI
correlation and huntingnotebooks over the lake
case managementTheHive, enrichment via Cortex
respondorchestration and runbooksShuffle
revocationyour own IdP and gateway, driven from the runbook
recoverhost and memory forensicsVelociraptor
run replaythe harness from C2.1, pinned per E5.1

Two honest notes about that table.

The DLP row is the weakest. There is no open-source DLP with the maturity of the other three, which is why the row names a pattern rather than a product — and why E1.1 scores DLP at almost no coverage of an agent's day. That is a real finding about the market, not a gap in the reading.

The agent-telemetry row does not exist in any of the products. Wazuh will tell you a process wrote a file. Nothing in the list tells you which prompt caused it. That row is instrumentation you write, it lands in the lake E2.1 designs, and its absence is what E1.1 measures.

The five chapters

E1 — discover. The four sensor classes you already own, scored against what an agent actually does; drift, the failure with no adversary at all; and a bonus on finding the agents nobody registered and keeping what they emit.

E2 — detect. The lake every rule is written against, then detections for two subjects that are not the same subject — the agent, and the platform running it — mapped to ATT&CK and ATLAS, plus the loop that writes rules, the benign corpus that decides whether they ship, and the one detector that needs no threshold.

E3 — understand. An investigation an agent can run: bounded before it starts, given the fields an agent alert needs, willing to abandon its first theory in the open, scoped along the delegation graph, widened to the population — and then the two proactive halves, third-party intelligence that has to become a rule and a hunt for behaviour no rule covers.

E4 — respond. A response whose blast radius is known before it fires. Actions classified on reversibility and radius, tiers derived from that rather than from their author, containment timed against the attacker, and a fleet stop that revokes as well as terminates.

E5 — recover and root cause. A run you can reproduce, a root cause that names a control rather than a person, the fix put at the layer it belongs in, the indicators re-measured to see which actually came back — and a regulatory clock that started before anyone knew.

Two rows of the CyberTravels register are this function's whole reason to exist: R9, where holding one agent reaches CRM, payroll and the cloud resource manager, and R10, where passport numbers are in the logs that would have told you.

2 · One hour of CyberTravels, one hour of Alex

signal, over one hourAlexCyberTravels' Workflow Agentratio
actions taken121,400117×
distinct resources touched526052×
median gap between calls180s2s1/90×
sessions19696×
typo / retry events30—
Every detection, baseline and playbook CyberTravels owns was tuned against the second column.

3 · Why a volume rule is not the answer

The obvious rule does fire. The problem is when — which is the one thing a table cannot show you, so this part is worth running.

4 · What CyberTravels has to emit before any of this works

what the SOC needsis it in an application log?which lesson gets it
the prompt that motivated the actionnoE1.3
the tool call, with argumentsnoE1.3
the decision, and what it was based onnoE5.1
which agent actednoE1.3
which human it acted fornoB2.7 · E1.3
the HTTP request the tool madeyesalready there
Five of six do not exist yet. R10 in the register is the sixth one's twin problem — the log you do have is full of passport numbers.

5 · The procedure, as a skill

Alex and CyberTravels' Workflow Agent, over the same hour. The skill measures the five signals that separate them, then runs the existing volume rule against the agent's run — where it fires 154 seconds in and stays silent for the remaining fifty-seven minutes.

▶Real time execution as skill

The skill — skills/detection/agent-tempo-baseline/SKILL.md

name: agent-tempo-baseline
description: >-
  Measure the behavioural signals that separate an agent's tempo from a
  person's — action rate, inter-action variance, session length, tool breadth,
  night-hours share — and check what a volume rule tuned for human tempo does
  when an agent runs. Use before writing any detection that will see agents.
allowed-tools: Read, Grep, Glob

The rule fires 154 seconds into a sixty-minute run

Detection content is calibrated on human tempo. An agent performs in an hour what a person performs in a month, so a volume rule does fire — immediately, and then not again for the rest of the run, which is the part that matters. The baseline has to be measured before any rule is written against it.

When to use this

Before authoring or tuning detections in an estate where agents act, and when an existing rule is either silent or permanently firing.

Procedure

1 — Pick one human and one agent doing comparable work. Same task class, same hour. Comparability is what makes the ratio meaningful.

2 — Measure five signals for each. Actions per hour, variance between actions, session length, distinct tools touched, and share of activity outside working hours. Report the ratio per signal — most will be in the hundreds.

3 — Run the existing volume rule against the agent's hour. Record when it first fires, in seconds. This is usually early enough that the rest of the run is unmonitored, which is the finding.

4 — Say what the rule now means. After the first firing it is silent for the remainder — so it is an onset detector, not a volume detector, and anyone relying on it for volume is relying on something else.

5 — Derive per-population thresholds. Humans and agents need different baselines, and an agent's baseline needs a per-agent one: a patch agent and a triage agent do not share a tempo.

Example

Input — the fixture committed at the top of scripts/agent_tempo_baseline.py. Edit it and re-run: the buckets, counts and verdicts below are derived from it, not hard-coded.

Output — the opening lines of a real run:

   Alex                12 actions/hour -> silent
   workflow agent    1400 actions/hour -> ALERT

the agent crosses the threshold after 154 seconds
and keeps going for the remaining 3446.

So the rule fires, about two and a half minutes into a sixty-minute run -
by which point most of what the actor was going to do is done. If those

The run continues past this. test_skills.py executes the script on every build, with no model configured — so what CI proves is that it runs and refuses legibly, not that it prints these lines. The output above is a recorded run against a real model, and nothing re-diffs it: a model's answer is not reproducible, and this repository does not claim otherwise anywhere it can be checked.

Output contract

{
  "subjects": [{"name": "str", "kind": "human|agent",
                "actions_per_hour": 0, "variance": 0.0, "session_minutes": 0,
                "distinct_tools": 0, "night_share": 0.0}],
  "ratios": {"str": 0.0},
  "existing_rule": {"threshold": 0, "first_fires_after_seconds": 0, "silent_after": true},
  "recommendation": {"per_population_thresholds": true, "populations": ["str"]}
}

Failure modes

  • Comparing an agent to an average human. Compare like work.
  • Reading an early firing as coverage. It is one alert and then silence.
  • One agent baseline for every agent. Their tempos differ as much as their jobs do.

Three ways to do this lesson. Pick one. They run the same procedure against the same code — what changes is who drives it, and how much you see.

1In your AI agent — you are taught

The agent reads the lesson, explains the idea, fetches the code, runs the check and answers your questions as you go. This is the one to take if you are here to learn.

Install it, once. From the folder you cloned. --all does every agent it finds on your machine:

python3 scripts/install_skills.py --all --lessons E1.0

Then restart your agent and open it in that folder. On Windows, if python3 says Python was not found, use python instead.

Then pick e1-0-start-here:

agentinstall just for this agentstart it
Claude Codepython3 scripts/install_skills.py --tool claude --lessons E1.0type /e1-0-start-here
GitHub Copilot (VS Code)python3 scripts/install_skills.py --tool copilot --lessons E1.0type /e1-0-start-here in Chat
Cursorpython3 scripts/install_skills.py --tool cursor --lessons E1.0type / in Agent chat and search for it
Codexpython3 scripts/install_skills.py --tool agents --lessons E1.0type $e1-0-start-here, or run /skills

2As one Python command — you just run it

No agent, no conversation. The same lesson executes and prints the same readback. Take this one if you have no assistant, if you are reviewing rather than learning, or if you want the result without the teaching around it.

python3 scripts/lesson.py E1.0

3Read the code, and the difference — nothing runs

Neither of the above, and no model needed. The first command writes CyberTravels exactly as it stood at the end of this lesson; the second prints the diff — the lines this lesson added or changed, and nothing from any later one.

python3 scripts/checkpoint.py --at E1.0 --out work/cybertravels
python3 scripts/checkpoint.py --at E1.0 --diff

On Windows, type python wherever these say python3 — and use \ instead of / in the paths. Everything else is identical. A0.0 step 2 explains why.

Ways 1 and 2 need a model; way 3 does not. A signed-in Claude Code CLI needs no API key, and any OpenAI-compatible endpoint works too. With neither, the audit exits 2 and says so rather than inventing an answer. A0.0 sets this up.

Ways 1 and 2 both end with the same readback: What I did, What changed, The number and Read this next. A step that was skipped or refused is reported as exactly that, never as a pass.

If you did the last lesson’s challenge, expect this to stop. Most challenges ask you to edit the code, and ways 1 and 2 will not overwrite your edits: you get stopped, not a failure, with two options — --out for a fresh folder that keeps your work, or --force to discard it and start this lesson clean.

✓What you just proved

Five behavioural signals for Alex and for CyberTravels' Workflow Agent over the same hour, with ratios in the hundreds. The volume rule tuned for human tempo does fire — 154 seconds into a sixty-minute run, leaving 3,446 seconds unmonitored. Five of the six things an agentic SOC needs are not in any application log.

✎Your turn

Pull one hour of activity for a service account in your own environment and compute those five signals. If you cannot, that is the first finding of chapter 8 and it is a telemetry problem rather than a detection one.

Skill source: skills/detection/agent-tempo-baseline

← PreviousD1.11 · Institutional governance and compliance