Oasis — One Agent Protects. One Agent Explains.

Project Story

Inspiration

Anyone who has worked with autonomous AI agents has seen their incredible potential. They can deploy code, triage system crashes, and trigger complex enterprise playbooks on the fly. It feels like magic until an agent gets compromised, behaves unexpectedly, or falls victim to a clever prompt injection exploit.

When an AI agent goes rogue inside a corporate network, it does not leave a neat, polite error message for a security team. Instead, it floods platforms like Splunk with a massive, chaotic avalanche of cryptic, raw machine logs.

I realized that Security Operations Center (SOC) teams are completely drowning in this data desert. An exploit can execute in a split second, buried deep inside thousands of lines of unreadable text. Expecting human analysts to trace and stop these anomalies in real time is a losing battle. The visibility gap is simply too wide.

That is why I built Oasis. I wanted to create a native, real-time security gateway for the Splunk ecosystem that gives enterprises the absolute confidence to run autonomous agent workflows without sacrificing human oversight or network control.

What it does

Oasis is a dual-agent security gateway engineered to protect, govern, and explain autonomous AI workflows in real time. Rather than just logging a catastrophe after it happens, Oasis steps inline to evaluate, filter, and translate activity via two distinct layers:

• Oasis Guard (The Protector): An inline, zero-trust gatekeeper. Before any automated agent instruction is allowed to reach backend data or execute a tool, Oasis Guard intercepts it. It evaluates the request across three parallel security dimensions: prompt injection scanning (OWASP LLM01), a live hallucination filter that queries the NIST National Vulnerability Database (NVD) API to drop fabricated CVEs (OWASP LLM09), and strict workspace permission validation (OWASP LLM08).
• Oasis Lens (The Explainer): Catching a threat is only half the battle. When a security event occurs, Oasis Lens leverages Splunk hosted Foundation-sec AI models to filter out the raw cryptographic noise. It instantly writes a clean, plain-English summary box explaining exactly what the agent tried to do, why it was blocked, and which system scopes were targeted.

The Core Validation Logic

To keep enterprise workflows moving at top speed, Oasis Guard evaluates incoming execution requests under a strict mathematical framework. The system acts as a hard binary validation function for an agent request $E$:

$$Oasis_Guard(E) = \begin{cases} 1 & \text{if } \sigma_{\text{inject}}(E) \land \sigma_{\text{hallucinate}}(E) \land \sigma_{\text{permit}}(E) = \text{True} \ 0 & \text{otherwise} \end{cases}$$

For this gateway to be viable in live enterprise environments, the total latency budget $T_{\text{total}}$ (the internal scanning time $t_{\text{scan}}$ combined with external API network roundtrips $t_{\text{api}}$) must never bottleneck the autonomous system:

$$T_{\text{total}} = t_{\text{scan}} + t_{\text{api}} < 200 \text{ ms}$$

Whenever a request fails the function (returning 0), it is instantly blocked and mapped straight to industry-standard MITRE ATT&CK matrix profiles (such as T1190 for exploit attempts or T1078 for credential abuse) before streaming natively into Splunk via the HTTP Event Collector (HEC).

How I built it

I engineered Oasis using a highly performant, production-ready enterprise stack built for speed, defense, and observability:

• The Core Gateway: Built with Python and FastAPI to leverage asynchronous network routines for zero-lag inline performance.
• The Interconnect Layer: Implemented using FastMCP, the official Model Context Protocol server framework, turning Oasis into a universal, ecosystem-agnostic plug-and-play network node.
• The Intelligence Layer: Powered by live connections to the NIST National Vulnerability Database REST API for threat correlation, alongside Splunk hosted Foundation-sec LLM for log abstraction.
• The SIEM Pipeline: Telemetry data streams seamlessly into Splunk Core using the native HTTP Event Collector (HEC), which feeds automated tracking directly into customized Splunk Dashboard Studio panels.

Challenges I ran into

My absolute biggest hurdle was balancing heavy security overhead with pure performance. Querying external vulnerability databases and running multi-layer string validation can easily cause latency lag. I spent a lot of late nights optimizing the data flows, relying heavily on asynchronous loops inside FastAPI and implementing a swift, in-memory cache for recurring permission boundaries to keep execution times strictly under that 200 ms threshold.

I also ran into massive data clutter. Raw system data streams are incredibly noisy and easily fill up a model context window. I had to carefully craft highly tailored regular-expression filters to isolate high-value security markers, allowing me to send clean, relevant data blocks to the Splunk Foundation-sec LLM without wasting tokens or sacrificing accuracy.

Accomplishments that I am proud of

• Sub-200ms Real-Time Defense: I successfully built a security gateway that scans text, checks an external government database, validates permissions, and makes an interception decision in a fraction of a second.
• Ecosystem Agnostic Architecture: By utilizing the new Model Context Protocol (MCP) standard, Oasis is not a rigid, fragile tool; it is a flexible server node that can seamlessly plug into any modern agent network.
• Humanizing the SOC: I created a framework that bridges the gap between machine-level complexity and human understanding, effectively turning unreadable cryptographic logs into plain, actionable English prose.

What I learned

This project opened my eyes to the reality that true security for the new era of agentic AI cannot be passive. You cannot just log a catastrophic failure and hope an analyst spots it on a chart the next day. Security must happen inline, at the protocol layer, before execution occurs. I also discovered that the emerging Model Context Protocol framework is an absolute game-changer for building modular, secure, and decoupled AI architectures.

What is next for Oasis — One Agent Protects. One Agent Explains.

I want to expand Oasis from an inline firewall into an adaptive security framework. My next immediate steps include:

1. Expanding the Threat Matrix: Deepening the security scanners to cover all 10 vulnerabilities in the OWASP LLM security index.
2. Adaptive Guardrails: Implementing lightweight reinforcement learning to allow Oasis Guard to dynamically adjust its safety thresholds based on the baseline behavior of specific enterprise workspaces.
3. Cross-Cloud Deployment: Scaling the FastMCP node architecture to support cross-cloud agent environments, ensuring that no matter where an enterprise AI agent is running, Oasis is there to protect and explain.

Built With

• 10
• and
• fastapi
• fastmcp-(model-context-protocol)
• for
• llm
• mitre-att&ck-matrix
• nist-nvd-api
• owasp
• python
• splunk-core
• splunk-dashboard-studio
• splunk-foundation-sec-llm
• splunk-hec-api
• top