Rakshastra — Autonomous AI Cyber Defense Agent
Rakshastra is an autonomous cybersecurity agent that turns fragmented security signals into an investigation plan, coordinated analysis, attack prediction, safe response, and resilience simulation — without requiring an analyst to manually drive every step.
Category: Fortified Enterprise Fleet
Repository: https://github.com/SKYGOD07/Rakshastra
Web Experience: https://rakshastra.vercel.app/
Why Rakshastra
Modern security operations are overloaded with disconnected signals: authentication events, endpoint activity, network telemetry, threat-intelligence reports, suspicious identities, vulnerabilities, and incident alerts.
The problem is not simply detecting one suspicious event. The hard part is turning many weak signals into one defensible decision.
An analyst may need to:
- normalize the alert,
- correlate entities across sources,
- retrieve relevant threat intelligence,
- determine whether the behavior matches a known threat actor,
- map the activity onto an attack graph,
- estimate the attacker's next move,
- determine the blast radius,
- choose a safe containment action,
- test that action in a simulated environment,
- and preserve an auditable investigation record.
Rakshastra is built to compress that workflow into an agentic security loop.
The goal is not to build another alert dashboard.
The goal is:
Detect → Correlate → Explain → Predict → Simulate → Respond → Learn
What Makes Rakshastra Agentic
Rakshastra goes beyond a normal chat interface.
A security request can be converted into a plan and delegated across specialized analysis workers. The repository contains a subagent delegation architecture in which child AI agents run with isolated context, restricted toolsets, separate task identities, and parallel execution support.
A typical investigation can therefore look like:
Security Alert
│
▼
Autonomous Orchestrator
│
├──► UEBA / Behavioral Analysis
├──► Threat Intelligence / RAG
├──► Entity Resolution
├──► APT Attribution
├──► Attack Graph Analysis
├──► Vulnerability Prioritization
└──► Digital Twin Simulation
│
▼
Evidence Correlation
│
▼
Gemini Reasoning Layer
│
▼
Risk + Recommended Action
│
┌─────┴─────┐
▼ ▼
Human Approval Safe Automation
│ │
└─────┬─────┘
▼
Audit / State
The orchestrator can therefore perform work in parallel rather than forcing the operator to manually execute every investigation step.
The Core Problem
Security teams face five recurring operational problems:
1. Fragmented evidence
Signals are distributed across identity systems, endpoints, networks, messaging platforms, applications, threat feeds, and historical investigations.
2. Alert fatigue
Traditional monitoring frequently produces alerts without enough context to explain what actually matters.
3. Slow investigation
Human analysts must repeatedly perform correlation, enrichment, attribution, graph traversal, and evidence review.
4. Risky automation
An automated response can cause damage when the system misunderstands the environment or acts on incomplete evidence.
5. Weak resilience testing
Organizations often know that a control exists, but not what happens to the attack path when that control changes.
Rakshastra addresses these problems as one connected agentic workflow.
What Rakshastra Does
1. Behavioral Intelligence / UEBA
Rakshastra builds behavioral context for users, hosts, services, and other entities and looks for deviations such as:
- unusual authentication behavior
- abnormal process execution
- network beaconing
- suspicious command execution
- privilege escalation bursts
- abnormal data staging
- multi-phase attack behavior
- behavior that does not yet match a known malware signature
The important point is that the system can use behavior as an investigation trigger instead of relying only on fixed signatures.
2. Threat Intelligence and APT Attribution
Observed activity can be mapped to threat-intelligence knowledge built around MITRE ATT&CK concepts and threat-actor profiles.
The platform supports:
- technique and tactic matching
- weighted similarity scoring
- confidence scoring
- actor clustering
- attack-pattern analysis
- hybrid retrieval using semantic and lexical search
The threat-intelligence pipeline combines Qdrant vector retrieval with SQLite FTS5/BM25 fallback and can incorporate CERT-In, CISA, and organization-specific security knowledge.
The result is a connected workflow:
Observed Telemetry
↓
Behavior / TTP Detection
↓
Threat Intelligence Retrieval
↓
APT Attribution
↓
Confidence + Evidence
3. Attack Prediction and Graph Intelligence
Rakshastra models infrastructure and relationships as graphs.
Nodes may represent:
- workstations
- servers
- identity systems
- domain controllers
- applications
- databases
- gateways
- other critical assets
Edges represent relationships such as connectivity, trust, or communication.
The graph engine can:
- identify attack paths
- trace possible lateral movement
- locate chokepoints
- calculate blast radius
- identify downstream exposure
- evaluate which controls could break an attack path
The prediction layer also uses state-transition / Markov-style modeling to estimate likely next adversarial moves.
Instead of stopping at:
“This event is suspicious.”
Rakshastra is designed to answer:
“This is the probable attack stage, these are the likely next moves, these assets are exposed, and these controls can interrupt the chain.”
4. Autonomous Incident Response / SOAR
Rakshastra turns analysis into controlled operational action.
The incident-response layer supports workflows for:
- triage
- investigation
- escalation
- containment
- playbook execution
- dry-run simulation
- incident closure
Potential response actions include:
- host isolation
- network blocking
- session termination
- credential revocation
- firewall controls
- ransomware containment
- other pre-approved actions
Rakshastra does not treat autonomy as unrestricted access.
High-impact actions can pass through approval, simulation, validation, sandboxing, and deterministic safety checks.
That creates a controlled-autonomy model:
AI Recommendation
↓
Policy Check
↓
Validation / Simulation
↓
Approval Gate (when required)
↓
Execution
↓
Audit Trail
5. Cyber-Resilience Digital Twin
Rakshastra can represent an organization's security topology as a virtual environment for what-if analysis.
An operator can:
- model infrastructure
- define an attack scenario
- choose an entry point
- simulate attack propagation
- calculate blast radius
- identify chokepoints
- apply hypothetical controls
- compare the resulting topology
Example questions:
What happens if this host is isolated?
What happens if this network edge is blocked?
What happens if MFA is enforced on this identity path?
Which control removes the largest portion of the attack graph?
This moves the platform from reactive monitoring toward cyber-resilience engineering.
6. Vulnerability Prioritization
A raw CVE list does not tell a security team what to fix first.
Rakshastra combines vulnerability information with operational context such as:
- CVE severity
- CVSS
- exploitability context
- network exposure
- asset criticality
- CERT-In / KEV-style intelligence
- remediation recommendations
- organizational context
The output is intended to be a prioritized remediation queue rather than a flat vulnerability inventory.
7. Multi-Source Correlation and Entity Resolution
Security incidents frequently reuse identities and infrastructure across different systems.
Rakshastra can normalize and correlate indicators including:
- phone numbers
- messaging handles
- usernames
- domains
- URLs
- invitation links
- crypto wallet addresses
- image/profile signatures
- investigation records
The entity-resolution layer can merge related aliases into unified profiles and produce graph-ready relationships.
8. Explainable AI
Rakshastra is designed so that an investigator can understand why the system reached a conclusion.
The reasoning layer can produce:
- threat summaries
- evidence explanations
- reasoning chains
- counter-evidence
- risk-score breakdowns
- investigator recommendations
- chronological investigation narratives
Instead of exposing only:
Risk = 87
the system aims to expose:
What happened
Why it is suspicious
Which evidence supports the decision
What evidence is missing
How the risk was built
What should happen next
What could happen if that action is taken
Agent Delegation and Specialized Execution
One of the most important agentic components is the delegation system.
The repository implements a delegate_task architecture that can spawn child AI agents with:
- isolated conversation context
- separate task identity
- restricted toolsets
- independent terminal sessions
- batch / parallel execution
- bounded delegation depth
- dangerous-tool blocking
- interrupt and runtime-status support
The architecture prevents child agents from recursively delegating work and blocks high-risk capabilities by default.
This is important because the security problem is naturally decomposable:
Parent Orchestrator
│
├── Threat Analysis Worker
├── Entity Correlation Worker
├── Graph / Attack Path Worker
├── Vulnerability Worker
└── Intelligence Retrieval Worker
The parent then combines the resulting evidence into a single decision.
Gemini-First Cognitive Layer
Gemini is positioned as the primary reasoning layer for Rakshastra.
The project uses Gemini for capabilities such as:
- structured investigation reasoning
- multimodal evidence interpretation
- function calling
- tool selection
- threat-intelligence synthesis
- report generation
- long-context analysis
The key design choice is that Gemini does not replace deterministic security systems.
Instead:
Deterministic Signals
+
Graph Algorithms
+
Threat Intelligence
+
RAG
+
Policy Checks
↓
Gemini
↓
Structured Decision
This grounds the agent in security evidence instead of asking the model to invent the underlying facts.
Memory, Retrieval, and Investigation State
Rakshastra uses multiple memory and retrieval mechanisms because security investigations require more than a single conversation window.
Semantic retrieval
Qdrant provides vector search for threat-intelligence and contextual retrieval.
Lexical retrieval
SQLite FTS5/BM25 provides a resilient lexical fallback and security memory layer.
Procedural memory
The Skills Hub stores reusable skills and playbooks that can be applied across investigations.
Persistent investigation state
Sessions and investigation records allow the platform to preserve context beyond a single prompt-response cycle.
Security and Governance
Autonomous cybersecurity systems need stronger controls than ordinary AI applications.
Rakshastra separates:
- reasoning
- tool selection
- execution
- policy
- validation
- audit
The execution layer supports local, Docker, and SSH environments with security guardrails.
The project also uses restricted subagent toolsets, dangerous-command handling, sandboxed execution, and approval mechanisms to reduce the risk of unintended actions.
The design principle is:
Controlled autonomy, not unrestricted autonomy.
Google Cloud and Hackathon Deployment
For the All Things Agentic Hackathon, Rakshastra is positioned as a security-focused enterprise agent running on Google Cloud infrastructure with Gemini as its cognitive layer.
The hackathon requires every submission to use:
- Gemini 3.5 or newer through the Gemini API or Vertex AI
- at least one Google agent framework
- at least one Google Cloud infrastructure service
The deployment should therefore be represented in the final demo and architecture as:
┌─────────────────────┐
│ Gemini 3.5+ │
│ Cognitive Layer │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ Rakshastra Agent │
│ Orchestrator │
└──────────┬──────────┘
│
┌────────────────┼────────────────┐
▼ ▼ ▼
Subagents / RAG + Memory Security Tools
Analysis Workers + Sandboxes
│ │ │
└────────────────┼────────────────┘
▼
Google Cloud State /
Deployment Services
│
▼
Web Dashboard
Important: the exact Google Agent Framework and Google Cloud service named in the Devpost submission should match the code and deployed environment shown in the demo. Do not claim a Google framework or Cloud service that is not actually used.
Why Fortified Enterprise Fleet
Rakshastra is best positioned for the Fortified Enterprise Fleet category because its security workflow naturally maps to institutional agent infrastructure:
Discovery and lifecycle
Reusable security skills, playbooks, agent capabilities, and specialized workers can be organized around a common security platform.
Core execution and state
The orchestrator delegates work to specialized agents while investigation state and procedural knowledge persist across operations.
Security and governance
Tool restrictions, approval gates, sandboxed execution, deterministic checks, and policy controls constrain high-impact actions.
Telemetry and observability
Subagent state, task identity, tool activity, investigation results, and audit information can be surfaced to the operator.
Most importantly, the system is solving a domain where coordination matters: cyber defense requires multiple analyses to converge before an organization takes a consequential action.
End-to-End Investigation Example
Consider a suspicious login combined with abnormal process activity.
1. Alert arrives
↓
2. Orchestrator creates investigation plan
↓
3. UEBA checks behavioral deviation
↓
4. Entity Resolver links identities and infrastructure
↓
5. Threat Intel worker retrieves related TTPs and reports
↓
6. APT engine estimates likely actor patterns
↓
7. Graph worker traces lateral movement paths
↓
8. Vulnerability worker identifies exposed weak points
↓
9. Attack Predictor estimates likely next move
↓
10. Digital Twin tests containment options
↓
11. Gemini synthesizes evidence and generates explanation
↓
12. Policy layer validates the response
↓
13. Human approval is requested when required
↓
14. Response is executed in a controlled environment
↓
15. Evidence and decision are recorded
That is the core idea of Rakshastra:
The agent does the investigation work instead of merely describing the work.
How We Built It
Frontend
- React
- TypeScript
- Vite
- TailwindCSS
- D3-style graph visualization
- operational security dashboards
The UI is organized around investigation and response workflows rather than generic analytics.
Backend
- Python
- FastAPI
- Pydantic
- modular service/controller architecture
- REST APIs
- WebSocket-capable infrastructure
- platform gateways
The system follows a layered path:
Request
↓
API
↓
Controller
↓
Service
↓
Intelligence Engine
↓
Memory / Execution
Intelligence Stack
The current architecture contains:
- UEBA
- APT attribution
- threat intelligence RAG
- graph analysis
- attack prediction
- entity resolution
- multi-source correlation
- explainable reasoning
- SOAR
- vulnerability prioritization
- digital twin simulation
Execution Stack
Rakshastra supports:
- local execution
- Docker sandboxing
- remote SSH execution
- terminal/process tools
- security skills and playbooks
- approval and command-safety controls
Data Sources
The platform is designed to work with a mixture of:
- security telemetry
- authentication data
- network events
- process and endpoint events
- threat-intelligence reports
- CERT-In / CISA security knowledge
- CVE and vulnerability data
- investigation history
- messaging and infrastructure indicators
- simulated infrastructure for digital-twin testing
The hackathon demonstration should clearly distinguish between real external data sources and controlled test/simulation data.
Challenges We Faced
Connecting many engines into one agent
The difficult part was not implementing individual security modules.
The real challenge was making one result meaningfully influence the next:
Anomaly
↓
Threat Intelligence
↓
Attribution
↓
Prediction
↓
Risk
↓
Response
↓
Simulation
↓
Defensive Improvement
This forced us to build around a common orchestration layer.
Making autonomy safe
Autonomous security actions can be dangerous.
The system therefore had to distinguish between:
- reasoning
- recommendation
- simulation
- approval
- execution
That led to sandboxing, deterministic validation, restricted tools, approval gates, and auditability.
Building a useful graph
A graph is not valuable just because it looks impressive.
It needs to answer:
- What is connected?
- What can an attacker reach?
- Where can lateral movement occur?
- What is the blast radius?
- What is the chokepoint?
- Which control changes the outcome?
That required both backend graph logic and a usable visual interface.
Balancing prototype data with real-world security
A hackathon cannot safely depend on privileged enterprise telemetry.
Rakshastra was therefore designed so that the same architecture can work with controlled test data, simulation, and future real integrations.
What We Learned
Cybersecurity is a correlation problem
The strongest signal is often the relationship between several weak signals.
AI needs deterministic grounding
LLMs are useful for interpreting evidence and coordinating actions, but the underlying security facts should come from verifiable systems.
Explainability is part of the security architecture
A decision that cannot be explained is difficult to trust.
Safe autonomy requires boundaries
Automation becomes useful only when the system knows what it is allowed to do, what it must simulate, and when a human must approve an action.
Agentic systems should perform work, not merely generate text
The biggest shift in Rakshastra was moving from:
Ask → Answer
to:
Goal → Plan → Delegate → Investigate → Decide → Act → Verify → Record
Production Direction
Rakshastra is designed to evolve toward a continuously available AI security operations layer.
Future integrations include:
- SIEM
- EDR
- NDR
- identity platforms
- cloud infrastructure
- endpoint events
- network telemetry
- richer threat-intelligence feeds
The long-term goal is an autonomous security lifecycle:
Monitor
↓
Detect
↓
Investigate
↓
Correlate
↓
Explain
↓
Predict
↓
Simulate
↓
Respond
↓
Learn
while keeping consequential decisions governed and auditable.
Final Positioning
Rakshastra is an autonomous AI cyber defense platform built to behave like a coordinated security team: it plans investigations, delegates analysis, correlates evidence, retrieves threat intelligence, predicts attack paths, simulates defensive controls, recommends or executes response actions within policy boundaries, and preserves an auditable investigation record.
The product is intentionally designed around the agentic principle behind the All Things Agentic Hackathon:
AI should not stop at answering the question. It should take responsibility for the work.
Log in or sign up for Devpost to join the conversation.