Inspiration The inspiration for DharmaGate Agentic Shield stems from the staggering velocity gap in modern defense: an AI-powered adversary can achieve full domain control in under 60 seconds, while human incident responders are still manually assembling their command-line toolkits. Manual DFIR operations can no longer match machine-speed exploits. We set out to prove that defenders can operate at identical speeds by bridging low-level system telemetry with type-safe autonomous loops, turning the SANS SIFT Workstation into an intelligent, self-correcting co-pilot.
What it does DharmaGate Agentic Shield translates raw forensic data into structured, actionable intelligence at machine speed. By listening to live kernel telemetry (e.g., eBPF events) and ingesting multi-source images (disk and memory captures), the system executes a continuous Cognitive Persistence Loop. The core autonomous agent queries data via a type-safe interface, correlates disparate artifacts (such as mismatching execution logs between disk and active memory RAM), and compiles full incident reports with a zero evidence spoliation footprint. If a tool fails due to execution discrepancies, the agent dynamically evaluates the error state, adjusts its parameters, and self-corrects without requiring operator intervention.
How we built it We constructed DharmaGate explicitly within the SANS SIFT Workstation VM. The stack consists of:
A Custom MCP Server (FastMCP): Wraps raw CLI forensics binaries (Volatility 3, SleuthKit, Plaso) into structured JSON-Schema functions, eliminating unsafe shell access entirely.
The Cognitive Orchestration Engine: A Python-based agent loop that manages state, monitors execution traces, and interfaces with frontier LLMs via JSON-RPC over stdio.
Automated Content Truncation Daemons: Built-in server-side processors that extract high-entropy forensic signals (such as process lineage anomalies) to prevent context window explosion.
Challenges we ran into Enforcing evidence integrity without restricting the agent's analytical capabilities was a severe architectural challenge. We discovered early on that relying on prompt instructions ("do not modify data") always leads to eventual spoliation during aggressive multi-step loops. We resolved this by physically locking down the data directories (chmod 444) and removing the shell execution layer entirely from the server. Furthermore, pre-parsing thousands of lines of disk timelines to avoid context window degradation required complex native truncation logic on the server side.
Accomplishments that we're proud of We successfully achieved an autonomous Self-Correction Sequence against a live target image. When Volatility failed due to missing OS symbol tables, our agent didn't crash; it captured the execution logs, modified its search configuration, retrieved the necessary symbol profile, and successfully completed the memory analysis loop. We have brought down complex case triage times from several hours of manual command matching to roughly 2.5 minutes of completely audited, autonomous execution.
What we learned We validated that for mission-critical AI operations, architecture must enforce constraints, not prompts. Non-deterministic models require entirely deterministic API boundaries (like type-safe MCP servers) to be reliable forensic partners. We also learned how to balance token usage metrics by implementing rigid reasoning schemas that prioritize high-entropy analytical anomalies over bulk raw text ingestion.
What's next for "DharmaGate Agentic Shield" Moving forward, we are expanding DharmaGate from passive investigation to active mitigation. We plan to integrate our eBPF/XDP network stack directly into the agent's available MCP tools, allowing the loop to autonomously deploy hardware-level rule blocks to ban malicious IPs or isolate compromised Docker containers in real time. We also intend to decompose our single-agent layout into a multi-agent framework to handle enterprise-scale telemetry feeds simultaneously.
Log in or sign up for Devpost to join the conversation.