AI Security’s 00M Week: Seven Startups Reshaping Cyber Defense From Endpoint to Offense

By /

Listen to this Post

Featured Image

Introduction:

The cybersecurity industry just witnessed one of its most consequential funding weeks, with seven startups emerging from stealth or securing major rounds totaling nearly $400 million. From Glow’s $180M prevention-first endpoint security platform to Neo’s $100M agentic software control layer, and from Twenty’s controversial $30M offensive cyber warfare expansion to Ossprey’s supply chain defense, the message is clear: AI has fundamentally altered the threat landscape, and legacy security tools are no longer sufficient. This article analyzes each company’s technology, provides hands-on security implementations, and explores what these investments signal about the future of cyber defense.

Learning Objectives:

  • Understand the seven major cybersecurity funding events and their technological implications
  • Learn practical implementation techniques for AI-driven security controls across endpoints, email, and supply chains
  • Master vulnerability prioritization using EPSS and predictive exposure management
  • Gain hands-on experience with composable SIEM architectures and in-stream detection
  • Explore offensive security automation and its defensive applications

You Should Know:

  1. Endpoint Security in the AI Era: Glow’s Prevention-First Model

Glow emerged from stealth with $180M at a $1.2B valuation, backed by Sequoia, Cyberstarts, Greenoaks, and Redpoint. Founded by former Meta VP of Engineering Roi Tiger, Snowflake’s Head of Cybersecurity Strategy Omer Singer, and Claroty’s VP of R&D Ophir Arie, the platform uses specialized AI agents to continuously map enterprise environments, assess risk in real time, and enforce security policies automatically.

The core insight: regular AI use on corporate devices has jumped from 15% to 45% in just one year, much of it unauthorized. Attackers now have access to Mythos-class AI capabilities, enabling them to exploit any overlooked gap at machine speed. Glow’s platform inverts the traditional detect-and-respond model by preventing malicious software, risky AI agents, and unauthorized apps from entering the environment in the first place.

Step-by-Step: Implementing Prevention-First Endpoint Controls

For organizations not yet using AI-driven endpoint platforms, here’s how to implement prevention-first controls using open-source and built-in tools:

Linux (using AppArmor and auditd):

 Enable and configure AppArmor for strict application control
sudo aa-enforce /etc/apparmor.d/usr.bin.firefox
sudo aa-status  Verify profiles are enforced

Implement file integrity monitoring to detect unauthorized changes
sudo apt install aide
sudo aideinit
sudo aide --check  Run baseline and verify

Block unauthorized executables using iptables and system call filtering
sudo iptables -A OUTPUT -m owner --uid-owner nobody -j DROP

Windows (using AppLocker and PowerShell):

 Enable AppLocker to enforce application control
Set-AppLockerPolicy -Policy "C:\Policies\AppLocker.xml" -Merge

Monitor for unauthorized software installations
Get-WinEvent -LogName "Microsoft-Windows-AppLocker/EXE and DLL" | 
Where-Object {$<em>.Id -eq 8003 -or $</em>.Id -eq 8004}

Implement Attack Surface Reduction rules
Set-MpPreference -AttackSurfaceReductionRules_Ids "75668C1F-73B5-4CF0-BB93-3ECF5CB7CC84" -AttackSurfaceReductionRules_Actions Enabled

Using Osquery for continuous endpoint monitoring:

-- Identify unauthorized running processes
SELECT name, path, pid, uid FROM processes 
WHERE name NOT IN ('ssh','bash','systemd','chrome');

-- Detect suspicious listening ports
SELECT port, protocol, pid, name FROM listening_ports 
WHERE port < 1024 AND name NOT IN ('systemd','sshd');

2. Agentic AI Control: Neo’s Real-Time Governance Layer

Neo raised $100M from Andreessen Horowitz and Bessemer Venture Partners to build a real-time control layer for agentic AI software. According to Gartner, only 5% of enterprise applications featured agentic capabilities in 2025, but 40% will by the end of 2026. Neo’s platform provides five core capabilities: software inventory covering AI agents, AI-enabled applications, plugins, extensions, MCP servers, and traditional software.

The platform enforces granular policies for tool calls, data movement, agentic workflows, and API access, with real-time attribution tracing individual software actions back to the originating human user, automated agent, or specific application identity.

Step-by-Step: Securing Agentic AI Workflows

API Gateway Configuration for AI Agent Control (using Kong or AWS API Gateway):

 Kong plugin configuration for rate limiting AI agent API calls
plugins:
- name: rate-limiting
config:
minute: 100
hour: 1000
policy: local

OPA (Open Policy Agent) policy for agent permissions
package agent.control

default allow = false

allow {
input.agent_id == approved_agents[bash]
input.action in ["read", "write"]
not input.sensitive_data
}

Validate MCP server configurations
mcp_servers:
- name: "database-agent"
allowed_tools: ["query", "analyze"]
max_tokens: 4096
rate_limit: 50/min

Monitoring AI Agent Behavior with OpenTelemetry:

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider

Trace agent actions for attribution
tracer = trace.get_tracer("agent.control")
with tracer.start_as_current_span("agent_action") as span:
span.set_attribute("agent.id", agent_id)
span.set_attribute("action.type", "tool_call")
span.set_attribute("target.system", target)
 Log policy enforcement decisions

3. Email Security Evolution: AegisAI’s Agentic Defense

AegisAI raised $36M in Series A led by Battery Ventures, bringing total funding to $49M. Founded by former Google security executives who worked on Safe Browsing and reCAPTCHA, the platform uses AI agents that analyze every email like a human analyst, detecting phishing, Business Email Compromise (BEC), and zero-day threats that bypass traditional rule-based filters.

AI-generated email attacks grew 5X in 2025, with sophisticated threats now bypassing traditional security filters more than 50% of the time. AegisAI’s agents can catch malicious PDF attachments with built-in passwords and CAPTCHA that fool standard spam filters.

Step-by-Step: Implementing AI-Powered Email Security

DMARC, DKIM, and SPF Configuration:

 Generate DKIM keys for your domain
openssl genrsa -out dkim-private.pem 2048
openssl rsa -in dkim-private.pem -pubout -out dkim-public.pem

Add to DNS (example zone file)
_domainkey IN TXT "v=DKIM1; k=rsa; p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC..."

SPF record
v=spf1 mx include:_spf.google.com ~all

DMARC policy
_dmarc IN TXT "v=DMARC1; p=quarantine; rua=mailto:[email protected]"

Email Threat Detection with AI (Python example using transformers):

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

Load phishing detection model
model = AutoModelForSequenceClassification.from_pretrained("phishing-detector")
tokenizer = AutoTokenizer.from_pretrained("phishing-detector")

def analyze_email(subject, body, sender):
text = f"{subject} {body}"
inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
outputs = model(inputs)
risk_score = torch.softmax(outputs.logits, dim=1)[bash][1].item()

Additional heuristics
indicators = {
"urgency_score": check_urgency_phrases(body),
"sender_reputation": check_sender_reputation(sender),
"link_risk": scan_links_for_malicious(body)
}
return {"risk_score": risk_score, "indicators": indicators}

4. Offensive Cyber Warfare: Twenty’s Industrial-Scale Automation

Twenty raised an additional $30M from Khosla Ventures at a $1.2B valuation, following a $100M Accel-led Series B. The company uses AI models from Anthropic and OpenAI to run hacking campaigns for the Department of War, automating identification of targets, reconnaissance, and post-compromise decision-making. CEO Joe Lin describes the mission as “industrializing cyber warfare,” moving from “highly artisanal” processes to ones that can “simultaneously prosecute hundreds of targets versus one at a time”.

While offensive in nature, Twenty’s automation techniques have defensive applications in red teaming and penetration testing.

Step-by-Step: Defensive Application of Offensive AI Techniques

Automated Vulnerability Scanning and Exploit Validation:

 Automated reconnaissance with Nmap and Nuclei
nmap -sV -sC -T4 -oA scan_results target.com
nuclei -l targets.txt -t cves/ -severity critical,high -o findings.txt

Automated exploit validation with Metasploit
msfconsole -q -x "use exploit/multi/http/struts2_content_type_ognl; 
set RHOSTS target.com; 
check; 
exit"

Red Team Automation with Python:

import subprocess
import concurrent.futures
from typing import List

def automated_recon(targets: List[bash]):
"""Parallel reconnaissance across multiple targets"""
with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
futures = []
for target in targets:
futures.append(executor.submit(run_recon, target))
results = [f.result() for f in futures]
return prioritize_targets(results)

def run_recon(target):
 Subdomain enumeration
subprocess.run(f"subfinder -d {target} -o subdomains.txt", shell=True)
 Port scanning
subprocess.run(f"naabu -host {target} -top-ports 1000 -o ports.txt", shell=True)
 Technology detection
subprocess.run(f"whatweb {target} -o tech.txt", shell=True)
return analyze_findings(target)

5. Composable Security Operations: Abstract’s SIEM Revolution

Abstract raised $25M co-led by Cheyenne Ventures and AVP, bringing total funding to nearly $50M at triple its prior valuation. The platform is built around composable security operations, an architectural approach that separates the source of security data from its destination, allowing organizations to mix and match components rather than being tied to a single vendor’s monolithic SIEM architecture.

The platform analyzes data while it’s still in motion rather than only after indexing, and tiers data to different storage destinations using schemas such as OCSF, ECS, and CIM.

Step-by-Step: Building a Composable SIEM with Open Source

ELK Stack with Custom Detection Pipelines:

 Logstash pipeline for in-stream detection
input {
beats { port => 5044 }
}
filter {
 Enrich with threat intelligence
elasticsearch {
hosts => ["localhost:9200"]
index => "threat_intel"
query => "threat.indicator: %{source.ip}"
}
 Run in-stream detections
if [event.type] == "authentication" and [event.outcome] == "failure" {
ruby {
code => "event.set('[bash]', 'brute_force_attempt')"
}
}
}
output {
elasticsearch { hosts => ["localhost:9200"] }
}

Sigma Rule for Detection Engineering:

title: Suspicious PowerShell Command
status: experimental
logsource:
product: windows
service: powershell
detection:
selection:
EventID: 4104
ScriptBlockText|contains:
- '-EncodedCommand'
- 'Invoke-Expression'
- 'DownloadString'
condition: selection
level: high

Using Falco for Runtime Security:

- rule: Terminal shell in container
desc: A shell was used as the entrypoint/exec point into a container with an attached terminal.
condition: >
spawned_process and container
and proc.name in (shell_binaries)
and proc.tty != 0
and not user_known_shell_spawn_activities
output: >
Shell spawned in a container (user=%user.name
container=%container.name
shell=%proc.name)
priority: WARNING

6. Predictive Vulnerability Management: Empirical Security’s AI Models

Empirical Security raised $25M in Series A led by Brightmind Partners. The founders previously built Kenna Security, popularizing risk-based vulnerability management. Their platform offers two predictive models: Foundation tracks over 18,000 CVEs with real exploitation activity globally, while Radiant trains on a single organization’s assets and telemetry to predict threats most relevant to that environment.

Vulnerability exploitation has overtaken stolen credentials as the top initial access vector, accounting for 31% of confirmed incidents, up from 20% a year earlier.

Step-by-Step: Implementing Predictive Vulnerability Management

Using EPSS (Exploit Prediction Scoring System) API:

 Query EPSS for CVE prioritization
curl -X POST https://api.first.org/epss/v1/cve \
-H "Content-Type: application/json" \
-d '{"cve": ["CVE-2024-12345", "CVE-2024-67890"]}'

Parse results and prioritize remediation
jq '.data[].epss' epss_results.json | sort -1r

Automated Vulnerability Prioritization Script:

import requests
import json

def prioritize_vulnerabilities(cve_list):
"""Prioritize CVEs using EPSS and local asset context"""
epss_scores = get_epss_scores(cve_list)
asset_context = get_local_asset_context()

prioritized = []
for cve in cve_list:
 Combine global EPSS with local exploitability
base_score = epss_scores.get(cve, 0)
local_risk = asset_context.get_asset_risk(cve, 1.0)
combined_score = base_score  local_risk

prioritized.append({
"cve": cve,
"priority_score": combined_score,
"has_exploit": check_exploit_db(cve),
"affected_assets": get_affected_assets(cve)
})

return sorted(prioritized, key=lambda x: x['priority_score'], reverse=True)

Integration with ticketing system
def create_remediation_tickets(prioritized_vulns, threshold=0.7):
for vuln in prioritized_vulns:
if vuln['priority_score'] > threshold:
create_jira_ticket(
summary=f"Remediate {vuln['cve']}",
priority="Critical",
description=f"EPSS score: {vuln['priority_score']}"
)

7. Supply Chain Security: Ossprey’s Malicious Code Detection

Ossprey raised $2.65M in pre-seed funding to tackle AI-driven software supply chain attacks. The platform continuously scans open-source packages for malicious code before they reach developers, catching what signature-based tools miss. The threat is becoming more urgent as developers rely heavily on AI coding assistants that increase the volume of software being written and deployed.

Step-by-Step: Supply Chain Security Implementation

Using OSS Audit Tools:

 Scan npm dependencies for vulnerabilities and malicious code
npm audit --production
npm audit fix

Python dependency scanning with safety and pip-audit
pip install safety pip-audit
safety check -r requirements.txt
pip-audit -r requirements.txt

Container image scanning
trivy image your-image:latest --severity CRITICAL,HIGH
grype your-image:latest --scope all-layers

Dependency Locking and Verification:

{
"name": "project",
"dependencies": {
"lodash": {
"version": "4.17.21",
"integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1W3BYujx6xNc6zq3",
"resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz"
}
}
}

Continuous Package Scanning with GitHub Actions:

name: Supply Chain Security
on: [push, pull_request]
jobs:
scan:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Scan npm dependencies
run: |
npm ci
npm audit --production --json > audit.json
- name: Check for malicious packages
run: |
npx @ossf/malicious-packages-check
- name: SBOM Generation
run: |
npm install -g @cyclonedx/bom
cyclonedx-bom -o bom.xml

What Undercode Say:

  • The prevention paradigm has finally arrived. Glow’s $180M round signals that investors believe AI has solved the core problem that made prevention impossible at scale—the ability to make granular, real-time risk decisions without blocking business. This represents a fundamental shift from the detect-and-respond model that has dominated cybersecurity for two decades.

  • Agentic AI is the next great security frontier. Neo’s $100M and the projection that 40% of enterprise applications will be agentic by year-end highlight an urgent reality: legacy security tools have no visibility into AI agents that can reason, act, and invoke tools autonomously. The security industry must develop new control layers for this rapidly expanding attack surface.

  • Offensive AI is both a threat and an opportunity. Twenty’s $30M from Khosla Ventures, with Pentagon as its sole customer, demonstrates that AI-powered offensive operations are now a reality. While concerning, the same automation techniques can revolutionize defensive red teaming and vulnerability validation.

  • Vulnerability management is becoming predictive. Empirical Security’s approach—using AI to predict which vulnerabilities will actually be exploited rather than relying on static severity scores—addresses the fundamental problem of alert fatigue. With exploitation now surpassing credential theft as the top initial access vector, this shift from reactive to predictive is critical.

  • The SIEM is being reinvented. Abstract’s composable architecture represents the first major rethinking of SIEM in two decades. By separating data sources from destinations, enabling in-stream detection, and embedding AI across the workflow, this approach addresses the cost and scalability problems that have plagued traditional SIEMs.

  • Supply chain security can no longer be an afterthought. Ossprey’s funding, though modest compared to others, signals growing recognition that AI-assisted coding has dramatically increased the volume and complexity of software dependencies. Malicious code injection into open-source packages is becoming the new frontier of cyber attacks, and signature-based detection is no longer sufficient.

Prediction:

  • +1 The $400M+ funding week will accelerate the consolidation of AI-1ative security platforms, with at least three of these seven companies reaching IPO or acquisition within 36 months, following the Wiz-Google trajectory.

  • +1 Prevention-first endpoint security will become the new industry standard by 2028, rendering traditional EDR solutions obsolete as organizations realize that blocking threats pre-execution is more cost-effective than responding to breaches.

  • -1 Agentic AI will be responsible for at least one major enterprise breach within 12 months, as organizations deploy autonomous agents without adequate security controls, validating the urgency of platforms like Neo.

  • +1 Predictive vulnerability management will reduce mean time to remediation by 60% within 18 months, as security teams stop treating all vulnerabilities equally and focus on those most likely to be exploited.

  • -1 The commoditization of offensive AI tools will lower the barrier to entry for cybercriminals, leading to a surge in automated, AI-driven attacks that outpace traditional defense mechanisms.

  • +1 Composable SIEM architectures will capture 30% of the SIEM market by 2028, as organizations abandon monolithic platforms in favor of flexible, cost-effective alternatives that give them control over their data and AI.

  • -1 Supply chain attacks will increase by 200% within two years as AI-assisted coding introduces more vulnerabilities and malicious packages into the open-source ecosystem.

🎯Let’s Practice For Free:

🎓 Live Courses & Certifications:

Join Undercode Academy for Verified Certifications

🚀 Request a Custom Project:

Secure, high-velocity infrastructure and disruptive technological engineering. Contact our engineering team for high-tier development and proprietary systems:
[email protected]
💎 Smart Architecture | 🛡️ Secure by Design | ⭐ Trusted by Thousands

IT/Security Reporter URL:

Reported By: Stuartstanton Cybersecurity – Hackers Feeds
Extra Hub: Undercode MoN
Basic Verification: Pass ✅

🔐JOIN OUR CYBER WORLD [ CVE News • HackMonitor • UndercodeNews ]

💬 Whatsapp | 💬 Telegram

📢 Follow UndercodeTesting & Stay Tuned:

𝕏 formerly Twitter 🐦 | @ Threads | 🔗 Linkedin | 🦋BlueSky

Related Posts: