Public cybersecurity learning atlas

Learn the system.Defend the outcome.

A structured map from engineering foundations to governed agentic AI—built from hands-on cybersecurity research, visual explanations, and implementation evidence.

Capability progression

01Foundation
02Build
03Secure
04Operate

Start with shared language. Add repeatable delivery. Secure the loop. Operate with evidence.

Choose a learning path

One map. Three practical journeys.

PATH 01

Agentic AI foundations

Build the mental models before adding autonomy.

Outcome: Choose confidently between chat, projects, skills, tools, a bounded agent loop, and multi-agent orchestration.

FoundationStart here

Governed Agentic AI for Cybersecurity

A four-session visual learning path from LLMs and reusable skills to agentic security risks, governed orchestration, and a hands-on cybersecurity agent workshop.

Agentic AILLMsAI securitycybersecurity

Interactive series

FoundationStart here

LLMs, prompts, and context: the useful mental model

Understand what an LLM actually does, how context shapes a response, and why confident language is not the same as verified knowledge.

LLMtokenscontextgrounding

Deep dive

FoundationStart here

Instructions, user requests, and data need different trust levels

Learn how instruction hierarchy works and why untrusted content must never acquire authority simply because an LLM can read it.

instructionstrust boundaryprompt designdata

Deep dive

FoundationStart here

From chat to projects: preserving useful working context

Choose between an ad-hoc conversation, a persistent project, and a reusable governed capability without adding autonomy too early.

chatprojectscontextknowledge

Deep dive

BuildIntermediate

Cybersecurity skill anatomy: package the method, not only the prompt

Structure repeatable cybersecurity expertise with an operating contract, focused references, schemas, deterministic scripts, and reusable assets.

skillsSKILL.mdscriptsschemas

Deep dive

BuildIntermediate

Function tools, MCP, and RAG solve different problems

Distinguish bounded actions, standardized capability connections, and evidence retrieval so the architecture matches the task.

function callingMCPRAGtools

Deep dive

BuildIntermediate

The agentic loop: reason, act, observe, and stop safely

Understand the runtime loop around a model and the state, limits, validation, escalation, and termination rules that make it governable.

agent loopstatebudgetssafe failure

Deep dive

BuildApplied

Single-agent and multi-agent orchestration: choose who owns the answer

Select manager, handoff, or code-led orchestration only when specialization and typed handoffs justify the coordination cost.

multi-agentmanagerhandoffsorchestration

Deep dive

PATH 02

Secure agentic systems

Treat every new capability as a new trust boundary.

Outcome: Design for prompt injection, excessive agency, poisoned context, guarded execution, and observable safe failure.

SecureStart here

Prompt injection: when untrusted data tries to become an instruction

Understand direct and indirect prompt injection, why prompt hardening is incomplete, and where system controls can still stop harm.

prompt injectionindirect injectiontrust boundaryOWASP

Deep dive

SecureIntermediate

Excessive agency: reduce function, permission, and autonomy

Control agentic risk by independently constraining what functions exist, which permissions they receive, and when autonomous execution is allowed.

excessive agencyleast privilegeautonomyblast radius

Deep dive

SecureApplied

Secure MCP, tools, retrieval, and agent memory

Threat-model capability connections, retrieved evidence, tool outputs, and durable memory as separate trust and data-governance boundaries.

MCP securityRAG poisoningmemorytool security

Deep dive

SecureApplied

Guardrails, human approval, and deterministic control planes

Place input, output, tool, policy, and human controls at the point where they can still prevent harm instead of relying on one filter.

guardrailsHITLpolicycontrol plane

Deep dive

SecureApplied

The secure agent technology stack: choose each layer by responsibility

Map UI, API, orchestration, models, tools, state, observability, evaluations, and guardrails to the problem each layer owns.

LangGraphAgents SDKLangfuseNeMo Guardrails

Deep dive

OperateApplied

Langfuse for cybersecurity: an SOC lens

How Langfuse traces, sessions, users, scores, evaluations and prompt versions help secure agentic systems—and why a SOC still needs a SIEM for correlation, incidents and response.

LangfuseLLM observabilitySOCSIEM

Deep dive

PATH 03

Cybersecurity Orchestrator

Turn specialist expertise into a governed delivery system.

Outcome: Understand the control spine, capability flows, architecture artifacts, lineage, and evidence-driven roadmap.

BuildStart here

Cybersecurity Orchestrator: the control plane is the product

Understand how one governed control spine coordinates specialist cybersecurity skills, deterministic gates, artifacts, and human decisions.

cyber orchestratorcontrol planeskillsdelivery

Deep dive

BuildApplied

Specialist capability flows for documents, Sentinel, CSPM, and architecture review

See how intake routes to document, architecture, compliance, detection, and cloud-posture specialists without losing ownership or evidence.

SentinelCSPMdocument buildersecurity architecture

Deep dive

BuildApplied

ArchStudio through MCP: generate quickly, assure deliberately

Separate fast diagram generation from premium architecture assurance while preserving editable artifacts, findings, and lineage.

ArchStudioMCPdraw.ioarchitecture assurance

Deep dive

OperateApplied

Artifacts, journals, and lineage: make the run explainable

Use typed artifacts for handoffs, a journal for authoritative actions and decisions, and observability traces for execution diagnosis.

artifactsaudit journallineageobservability

Deep dive

OperateApplied

Current-state and future-state agentic security architecture

Communicate what is implemented now, what evidence supports it, and which controls are planned without presenting a roadmap as production reality.

roadmapcurrent statefuture stategovernance

Deep dive

PATH 04

Build and secure an agent

Move from bounded task to defensible release evidence.

Outcome: Build, threat-model, attack, evaluate, and make an accountable ship decision for a first cybersecurity agent.

BuildStart here

Build and secure your first cybersecurity agent

A practical build sequence from bounded task and non-goals through skill, structured output, narrow tools, controls, attack tests, and ship decision.

workshopsecure agentarchitecture reviewbuild guide

Hands-on guide

SecureIntermediate

Threat-model the agent workflow before choosing tools

Map assets, actors, trust boundaries, data flows, abuse paths, side effects, and recovery before granting an agent capabilities.

threat modelingtoolsdata flowSTRIDE

Deep dive

OperateApplied

Agent evaluations and release readiness: prove repeatability

Combine deterministic tests, human review, model-based evaluation, adversarial cases, operational thresholds, and rollback evidence into a ship decision.

evaluationsLLM-as-judgered teamingrelease readiness

Deep dive

PATH 05

Detection engineering

Turn detection logic into a testable, governed delivery pipeline.

Outcome: Ship Sentinel analytics with traceable changes, automated quality gates, and deployment discipline.

BuildIntermediate

Detection-as-Code: the pipeline & governance

How analytic rules move from an engineer's idea to a production Sentinel workspace — repo strategy, deploy engines (ARM vs Terraform), CI vs CD, IaC vs API, and the governance case.

SentinelGitHub ActionsAzure DevOpsTerraform

Deep dive

SecureApplied

Validating Sentinel detections in CI/CD

The three tiers of KQL validation — static lint, syntax/schema check, and functional 'does it fire' testing — mapped to SAST, compile, and DAST, and placed in the pipeline as a shift-left gate.

SentinelKQLCI/CDSAST

Hands-on guide

PATH 06

Engineering foundations

Build the collaboration habits that make automation safe to change.

Outcome: Use branches, pull requests, conflict handling, and worktrees confidently across parallel work.

FoundationStart here

Git collaboration: branches, forks & conflicts

How multiple people work on one repo without colliding — the contribution flow, shared-repo vs fork model, why one branch per task, and exactly what happens when two people push to the same branch.

GitGitHubpull requestsmerge conflicts

Hands-on guide

BuildIntermediate

Git worktrees: many branches at once

The working tree explained, then git worktree — one repository with several branches checked out in parallel folders. When you need it (hotfix mid-feature, PR review, parallel builds) and how it works.

Gitworktreebranchingworkflow

Hands-on guide