This starts chapter E1. Its course guide is E1 in the Function E course guide →
Not recorded yet. The lesson below is complete and runnable today — the video is added later without touching this page.
recordings/E1.0.mp4A detection stack tuned for human tempo, watching an actor that acts a thousand times an hour and never repeats a session.
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.
Put one agent trace and one human session side by side and list what separates them.
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.
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.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.
A detection stack tuned for human tempo, watching an actor that acts a thousand times an hour, reports nothing and means nothing.
Learn the five intervals and the open-source stack that measures them, before building anything.
The five intervals themselves — discover, detect, understand, contain, recover. Every later lesson moves one of them.
Measure this
| what to measure | denominator or target |
|---|---|
| the five intervals themselves | discover, detect, understand, contain, recover — in minutes; every later lesson moves one |
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.
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:
| interval | from | to | chapter |
|---|---|---|---|
| discover | the behaviour happens | somebody could see it at all | E1 |
| detect | it is visible | an alert exists | E2 |
| understand | the alert exists | a conclusion you can act on | E3 |
| contain | the conclusion | the actor stopped | E4 |
| recover | stopped | the control measurably back at target | E5 |
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.
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.
| phase | what has to exist | open source that does it |
|---|---|---|
| discover | endpoint and workload sensing | Wazuh (agent, manager, indexer) |
| cloud posture, on a schedule | Prowler, ScoutSuite | |
| container runtime and image contents | Falco, Trivy | |
| sensitive content in motion | regex plus Wazuh file integrity monitoring | |
| agent traces — prompts, tools, decisions | OpenTelemetry, instrumented at the gateway | |
| detect | somewhere for all of it to land | OpenSearch (or the Wazuh indexer) |
| rules, portable and reviewable | Sigma, mapped to ATT&CK and ATLAS | |
| deception with no threshold | canary tokens and honeypot tasks you write | |
| understand | third-party intelligence | MISP, OpenCTI |
| correlation and hunting | notebooks over the lake | |
| case management | TheHive, enrichment via Cortex | |
| respond | orchestration and runbooks | Shuffle |
| revocation | your own IdP and gateway, driven from the runbook | |
| recover | host and memory forensics | Velociraptor |
| run replay | the 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.
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.
| signal, over one hour | Alex | CyberTravels' Workflow Agent | ratio |
|---|---|---|---|
| actions taken | 12 | 1,400 | 117× |
| distinct resources touched | 5 | 260 | 52× |
| median gap between calls | 180s | 2s | 1/90× |
| sessions | 1 | 96 | 96× |
| typo / retry events | 3 | 0 | — |
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.
| what the SOC needs | is it in an application log? | which lesson gets it |
|---|---|---|
| the prompt that motivated the action | no | E1.3 |
| the tool call, with arguments | no | E1.3 |
| the decision, and what it was based on | no | E5.1 |
| which agent acted | no | E1.3 |
| which human it acted for | no | B2.7 · E1.3 |
| the HTTP request the tool made | yes | already there |
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.
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, GlobDetection 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.
Before authoring or tuning detections in an estate where agents act, and when an existing rule is either silent or permanently firing.
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.
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.
{
"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"]}
}
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.
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.0Then 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:
| agent | install just for this agent | start it |
|---|---|---|
| Claude Code | python3 scripts/install_skills.py --tool claude --lessons E1.0 | type /e1-0-start-here |
| GitHub Copilot (VS Code) | python3 scripts/install_skills.py --tool copilot --lessons E1.0 | type /e1-0-start-here in Chat |
| Cursor | python3 scripts/install_skills.py --tool cursor --lessons E1.0 | type / in Agent chat and search for it |
| Codex | python3 scripts/install_skills.py --tool agents --lessons E1.0 | type $e1-0-start-here, or run /skills |
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.0Neither 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 --diffOn 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.
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.
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