AI integration for threat intelligence in Splunk focuses on three key surfaces: the Splunk Common Information Model (CIM) for Threat Intelligence, the threat_activity and threat_intel data models, and the lookup and kvstore commands used to enrich events. The workflow begins with AI agents monitoring connected threat intelligence feeds (e.g., via HTTP Event Collector or Splunk Add-on for APIs). These agents don't just forward raw reports; they use LLMs to extract structured indicators (IPs, domains, file hashes) and, more importantly, to parse narrative context—mapping tactics to the MITRE ATT&CK framework, summarizing actor motivations, and extracting likely next steps. This processed intelligence is then written to a Splunk KV Store collection or a lookup CSV file with enriched fields like tactic, technique_id, confidence_score, and ai_summary.
Integration
AI Integration for Automated Threat Intelligence for Splunk

Where AI Fits in Splunk's Threat Intelligence Workflow
A practical blueprint for automating threat intelligence ingestion, processing, and application in Splunk using AI.
The real operational value comes from applying this enriched intelligence. AI-driven Splunk saved searches or Scheduled Reports can be triggered on new intelligence ingestion. These searches use the enriched data to: 1) Create or tune detection SPL by generating correlation searches that look for the newly identified techniques in your firewall, dns, or endpoint data. 2) Retroactively hunt across historical data using the new IOCs and behavioral patterns. 3) Prioritize existing alerts by scoring Splunk Notable Events based on overlap with high-confidence, recent threat intel. This moves teams from a reactive IOC-matching stance to a proactive, behavior-informed detection posture, often surfacing attacks that generic IOCs would miss.
For governance, this integration should be built with a human-in-the-loop approval step before AI-generated detection searches are promoted to production. Use Splunk's Alert Actions or integrate with Splunk SOAR (formerly Phantom) to route suggested SPL for analyst review. All AI-generated content—extracted IOCs, ATT&CK mappings, and proposed searches—should be logged to a dedicated ai_audit index with traceability back to the source report and model version. Rollout typically starts with a single, high-fidelity threat feed, using the AI to demonstrate time saved in manual report processing and increased detection coverage before scaling to additional sources.
Key Splunk Surfaces for AI Threat Intelligence Integration
Threat Intelligence Management (TIM) App
The Splunk Threat Intelligence Management (TIM) app is the primary surface for ingesting, normalizing, and applying threat intelligence. AI integration here focuses on automating the enrichment and actionability of raw intelligence feeds.
Key AI Integration Points:
- Automated IOC Extraction: Use NLP models to parse unstructured threat reports, blogs, and vendor alerts to extract IPs, domains, hashes, and MITRE ATT&CK techniques, then format them into STIX/TAXII for TIM ingestion.
- Confidence Scoring & Prioritization: Apply ML models to score IOCs based on recency, source reputation, and prevalence in your environment. Automatically assign higher priority to IOCs that map to active threat campaigns targeting your industry.
- Lookup Table Management: Use AI to dynamically manage and prune TI lookup tables. Identify stale or low-value indicators that haven't matched any internal data over a defined period and archive them to optimize search performance.
Integrating AI at the TIM layer transforms passive data feeds into a curated, prioritized intelligence stream that directly fuels detection engineering.
High-Value Use Cases for Automated Threat Intelligence
Automating the ingestion, processing, and application of threat intelligence in Splunk reduces analyst fatigue and accelerates detection engineering. These use cases focus on connecting AI to Splunk's data pipeline, search processing language (SPL), and notable event framework to operationalize raw feeds and reports.
Automated IOC Extraction & Enrichment
AI parses unstructured threat reports, blogs, and RSS feeds to extract IOCs (IPs, domains, hashes). It normalizes and enriches them with context (geolocation, ASN, malware family) before writing to a threat_intel lookup or KV store. Workflow: Scheduled search ingests raw text → AI service extracts entities → Lookup is updated → Detection searches automatically reference the enriched list.
ATT&CK Framework Mapping for Detections
AI analyzes new detection SPL or notable event patterns and maps them to the MITRE ATT&CK framework. It suggests relevant technique IDs (T####) and tactic names, auto-populating custom fields like mitre_technique_id. Workflow: New correlation search is saved → AI reviews SPL logic and past alerts → Suggests ATT&CK mapping → Populates ES notable event annotation for richer reporting and gap analysis.
Dynamic Detection Search Generation
Given a new threat intel report describing a TTP, AI drafts a prototype Splunk detection search (SPL). It identifies relevant data sources (e.g., WinEventLog:Security, stream:dns), suggests field extractions, and includes logic for filtering false positives. Workflow: Analyst uploads report → AI outputs SPL skeleton → Engineer reviews and tunes → Search is deployed via Git or Deployment Server.
Threat Intel-Driven Alert Tuning
AI monitors the performance of existing detection searches that use threat intel lookups. It analyzes false positive rates and matches against internal network logs to recommend retiring stale IOCs or adjusting search thresholds. Workflow: AI job runs weekly → Reviews threat_intel lookup usage stats → Flags low-fidelity IOCs → Creates ServiceNow ticket or PR to update the source list.
Natural Language Threat Hunting
Analysts use a natural language interface (e.g., a custom dashboard input) to ask questions like "Show me connections to IPs associated with APT29 in the last 48 hours." AI translates this into optimized SPL, executes it, and returns a summary of findings. Workflow: Query entered → AI generates SPL joining network data with threat_intel lookup → Results displayed in dashboard with key highlights.
Automated Intelligence Report Summaries
AI ingests lengthy vendor threat reports (PDFs, blogs) and generates executive summaries, highlighting key IOCs, likely targets, and recommended Splunk detection strategies. The summary is posted to a Slack channel or saved as a notable event in Splunk for analyst review. Workflow: New report detected in shared drive → AI processes and summarizes → Summary posted to SOC channel & saved to intel_summaries index.
Example Automated Threat Intelligence Workflows
These workflows demonstrate how AI agents can automate the ingestion, processing, and application of threat intelligence within Splunk, moving from manual feed review to automated IOC extraction, ATT&CK mapping, and proactive detection tuning.
Trigger: A new threat intelligence report (PDF, blog post, tweet) is posted to a monitored RSS feed, email inbox, or webhook.
Context/Data Pulled: The raw, unstructured text is retrieved. The Splunk lookup command checks the threat_intel KV store for existing IOCs to avoid duplicates.
Model or Agent Action: An LLM agent with a structured output schema (JSON) is prompted to:
- Extract all IOCs (IPs, domains, URLs, file hashes, registry keys).
- Classify each IOC type and provide confidence scores.
- Summarize the associated threat (e.g., "Credential-stealing malware targeting finance sector").
- Map likely ATT&CK techniques (e.g.,
T1566.001for phishing).
System Update or Next Step: The agent's JSON output is sent via HEC to a dedicated ti_processing index. A scheduled SPL search ingests this data, uses | inputlookup append=true to update the threat_intel KV store, and creates a new threat_intel_source event in the main index for audit.
Human Review Point: A summary dashboard tile shows "New IOCs Extracted (Last 24h)" with a drill-down to the source report and extraction results. Analysts can review low-confidence extractions flagged by the model.
Implementation Architecture: Data Flow and Integration Points
A practical architecture for automating the ingestion, enrichment, and operationalization of threat intelligence within Splunk, moving from manual feed management to AI-driven detection tuning.
The integration connects at three primary points within the Splunk ecosystem: the inputs.conf layer for ingesting raw intelligence reports (PDFs, blogs, RSS), the Search & Reporting App (SPL) for processing and extracting IOCs, and the Enterprise Security Content Updates (ESCU) or custom detection search layer for applying the refined intelligence. The core AI agent acts as an intermediary processor, subscribing to new data in a dedicated threat intel index via HTTP Event Collector or monitoring a designated S3 bucket/email inbox for new reports. Upon ingestion, the agent uses a vision-capable LLM to parse unstructured text and images, extracting entities like IPs, domains, file hashes, and mutex names, then maps them to the MITRE ATT&CK framework using a combination of LLM reasoning and a vector store of technique descriptions.
The enriched output is written back to Splunk as structured JSON into a threat_intel_processed index. A second orchestration layer, often implemented as a Splunk saved search or a lightweight external microservice, periodically queries this index for new, high-confidence IOCs. It then performs two key actions: 1) Updating Splunk Enterprise Security's Threat Intelligence Management (TIM) via its REST API to populate KV Store collections, making IOCs available for real-time correlation, and 2) Generating or tuning SPL detection searches. For example, the AI can draft a new correlation search for a novel TTP, test it against historical data for noise, and deploy it via the Splunk REST API or an alert_actions.conf script. This creates a closed loop where analyst investigations of AI-enriched alerts can feed back into the intelligence model, refining future extraction priorities.
Governance is critical. All AI-extracted IOCs should pass through a confidence-scoring and approval workflow before automated deployment. Low-confidence extractions can be routed to a review dashboard in Splunk or a separate ticketing system. The architecture should maintain a full audit trail in Splunk's internal index, logging the source document, extracted entities, ATT&CK mapping, and any automated actions taken (e.g., "search_updated"). Rollout typically starts with a single, high-value intelligence feed (e.g., a trusted vendor's weekly report) in a monitoring-only mode, comparing AI extractions against manual analyst work to tune prompts and confidence thresholds before enabling any automated search generation.
Code and Payload Examples
Ingesting and Parsing Raw Threat Feeds
AI models process unstructured threat intelligence (TI) reports, blogs, and raw feeds to extract structured Indicators of Compromise (IOCs). This step transforms free-text into actionable data for Splunk. A common pattern involves a scheduled Python service that fetches feeds, uses an LLM to parse and classify, and outputs JSON for Splunk's HTTP Event Collector (HEC).
python# Example: Using an LLM to extract IOCs from a threat report import json import requests from inference_client import InferenceClient client = InferenceClient(api_key="your_key") raw_report = fetch_threat_feed("https://feed.example.com/latest") prompt = f"""Extract all IOCs from this threat report. Return a JSON list with fields: type (ip, domain, hash, url), value, context. Report: {raw_report} """ response = client.chat.completions.create( model="gpt-4o", messages=[{"role": "user", "content": prompt}], response_format={ "type": "json_object" } ) iocs = json.loads(response.choices[0].message.content) # Send to Splunk HEC for ioc in iocs["iocs"]: payload = { "event": ioc, "sourcetype": "ti:ioc_extracted", "source": "ai_ti_pipeline" } requests.post('https://splunk-hec:8088/services/collector', headers={'Authorization': 'Splunk <HEC_TOKEN>', data=json.dumps(payload))
Realistic Time Savings and Operational Impact
How AI integration transforms manual, reactive threat intelligence processes in Splunk into a proactive, analyst-accelerated workflow.
| Workflow Stage | Before AI | After AI | Key Notes |
|---|---|---|---|
Threat Feed Ingestion & Parsing | Manual review of raw reports and blogs | Automated extraction of IOCs and TTPs | AI parses unstructured text from PDFs, blogs, and RSS feeds into structured data |
Indicator (IOC) Enrichment & Scoring | Static scoring based on feed source | Dynamic risk scoring using internal context | Scores incorporate internal prevalence, asset criticality, and ATT&CK mapping |
Detection Search Creation/Tuning | Manual SPL writing and testing | Assisted generation and optimization of SPL | AI suggests new correlation searches or tunes existing ones based on extracted TTPs |
ATT&CK Framework Mapping | Analyst manually maps IOCs to techniques | Automated mapping with analyst validation | Provides immediate context for threat hunting and control gap analysis |
Threat Intelligence Dashboard Updates | Manual curation and static reporting | Dynamic, context-aware dashboard widgets | Dashboards automatically highlight relevant intel for active incidents |
False Positive Triage for New IOCs | Reactive, after alerts fire | Proactive simulation against historical data | Predicts potential alert volume and false positives before deployment |
Threat Brief Creation for Stakeholders | Hours to draft and format | Minutes to generate first draft | AI synthesizes feed data into executive summaries; analyst reviews and finalizes |
Governance, Security, and Phased Rollout
A production-grade AI integration for Splunk threat intelligence requires deliberate controls, data security, and a phased approach to manage risk and prove value.
Governance starts with defining the scope of AI's role within the Splunk Threat Intelligence Platform (TIP) workflow. This typically involves creating a dedicated ai_processing index or sourcetype for audit trails, establishing RBAC policies to control who can trigger AI enrichment jobs or view AI-generated insights, and implementing approval gates for any AI-suggested changes to critical objects like threat_intel lookups or savedsearches. The AI should operate as a privileged service account, with its actions logged to Splunk's internal indexes for full traceability, ensuring you can answer what the AI did, when, and why for every IOC processed.
Security is paramount when processing sensitive threat data. The integration architecture should ensure threat intelligence payloads are encrypted in transit (via Splunk's HTTPS Event Collector or authenticated APIs) and at rest. AI model calls should be made through a secure gateway that enforces data loss prevention (DLP) policies, stripping any accidental internal IPs or hostnames from the data sent for external processing. For on-premises or VPC deployments, we recommend using private endpoints for models like Azure OpenAI or AWS Bedrock to keep all data within your trusted network, preventing any external exposure of your threat intelligence corpus.
A phased rollout mitigates risk and builds confidence. Phase 1 (Pilot): Target a single, high-volume, low-risk threat feed (e.g., a public IP blocklist). Use AI to extract and normalize IOCs into a test lookup, validating accuracy against manual samples. Phase 2 (Expansion): Apply AI to enrich internal investigation cases, automatically mapping IOCs from analyst notes to the MITRE ATT&CK framework. Implement a human-in-the-loop review step in a Splunk dashboard before any automated detection tuning. Phase 3 (Automation): Enable closed-loop workflows where high-confidence AI outputs can automatically create or tune correlation searches in Splunk Enterprise Security, with changes logged as notable events for the SOC manager. Each phase includes defined success metrics (e.g., reduction in manual processing time, increase in IOC attribution coverage) and rollback procedures.
This controlled approach ensures the AI augments—rather than disrupts—your existing Splunk security operations. By treating the AI as a new, auditable data source and automation actor within your Splunk ecosystem, you maintain operational control while systematically unlocking efficiency gains in threat intelligence processing and application.
Enabling Efficiency, Speed & Accuracy
Intelligent Analysis, Decision & Execution
We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.
Talk to Us
Search across company data
Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.
Useful when people spend too long searching or get different answers from different systems.

Automate internal workflows
Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.
Useful when repetitive work moves across multiple tools and teams.

Add AI to products and internal tools
Build assistants, guided actions, or decision support into the software your team or customers already use.
Useful when AI needs to be part of the product, not a separate tool.
Frequently Asked Questions
Practical questions for teams evaluating AI to automate threat intelligence ingestion, processing, and application within Splunk.
AI integrates with Splunk's data ingestion layer and search processing language (SPL) to automate the enrichment and application of threat intelligence (TI). A typical implementation involves:
- Trigger: A scheduled search or a webhook from an external TI feed (e.g., AlienVault OTX, Recorded Future) signals new intelligence is available in a Splunk index or an S3 bucket.
- Context Pulled: An AI agent retrieves the raw TI report (PDF, JSON, blog post) via the feed's API or from the Splunk index where it was dumped.
- Agent Action: A multi-step AI process extracts structured indicators (IPs, domains, hashes) and, more importantly, analyzes the narrative to:
- Map described TTPs to the MITRE ATT&CK framework.
- Identify the likely threat actor and campaign.
- Summarize the report's key findings and confidence level.
- System Update: The AI agent writes the structured output back to a dedicated Splunk lookup table (e.g.,
threat_intel_summary) and creates or updates detection searches in theScheduled Searchesconfiguration via the Splunk REST API. For example, it might generate a new correlation search looking for the extracted IOCs alongside the mapped TTPs. - Human Review: Newly created detection searches can be flagged for analyst review in a dashboard before being enabled, ensuring governance.

About the author
Prasad Kumkar
CEO & MD, Inference Systems
Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.
His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.
Partnered with leading AI, data, and software stack.
How We Work
Custom AI workflows for your Business
One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.
01
Review the use case
We understand the task, the users, and where AI can actually help.
Read more02
Pick the right approach
We define what needs search, automation, or product integration.
Read more03
Build the first useful version
We implement the part that proves the value first.
Read more04
Improve from there
We add the checks and visibility needed to keep it useful.
Read moreThe first call is a practical review of your use case and the right next step.
Talk to Us