CSO Online's August piece AI agents aren't going rogue. Frontier labs are skipping security basics pulled 517 points and 218 comments on the Hacker News front page. That alone tells you something: the developer community has stopped buying the "AI awakening" narrative.
The article's argument is straightforward. Incidents aren't happening because agents make autonomous decisions. They're happening because frontier labs are skipping the same boring engineering fundamentals Web security has preached for two decades: input validation, permission scoping, sandbox isolation, audit logs, and human-in-the-loop checks.
Here's how the threads in the piece connect, plus some of my own takes.
What the Article Is Actually Arguing
CSO Online's logic runs counter to the dominant narrative:
- Default narrative: agents gain autonomy → become uncontrollable → runaway incidents → regulation
- Article's claim: agents aren't running away, deployers are skipping basics → runaway incidents → engineering accountability
The second framing is friendlier to CISOs. "AI is uncontrollable" pushes blame onto model vendors and regulators. "You skipped input validation" pins responsibility on the in-house security team, but it also gives that team a path forward.
The 218 comments clustered around three themes:
- This is the same way Web apps died in 2010
- Frontier labs aren't the only offenders; open-source agent frameworks are often rougher
- Anyone who's shipped one knows business stakeholders refuse to add these checks
The third point is the engineering reality. More on that below.
The 5 "Boring" Basics Being Skipped
The article lists several. I've ranked them by impact. Each one is a 20-year-old Web security chestnut the agent ecosystem has collectively forgotten.
1. Input validation on tool calls
LLM-generated SQL goes straight to the database. LLM-generated shell commands execute as-is. This isn't hypothetical. Autogen and CrewAI behave this way by default. Tool signatures are just prompt hints, with no runtime schema enforcement.
# Anti-pattern: LLM-generated query executes directly
def run_sql(query: str):
return db.execute(query) # LLM says "DROP TABLE users" and you drop
# What it should look like
from pydantic import BaseModel, Field
class ReadQuery(BaseModel):
query: str = Field(..., pattern=r"^SELECT.*FROM\s+\w+(\s+WHERE.*)?$")
def run_sql(q: ReadQuery):
if not q.query.upper().startswith("SELECT"):
raise ValueError("Only SELECT allowed")
return db.execute(q.query)
2. Least privilege
Give an agent shell access and it can run rm -rf. Give it email access and it can spam your entire org. LangGraph and AutoGen's tool registration APIs don't constrain permission granularity. It's all or nothing.
3. Sandbox isolation
Browser agents run in the host process. Filesystem agents read and write directly to the user's home directory. Code-execution agents run in the main process. None of this should be in production. All of it ships in "demo mode" today.
4. Audit logs
When something breaks, nobody knows what the agent did. LangChain's default verbose=True just prints to stdout. OpenAI's function calling doesn't log call arguments by default. Forensics after the fact? Forget it.
5. Human-in-the-loop
No confirmation on critical actions. Sending email, transferring funds, modifying databases. The agent decides on its own. Pull this one out and it might be the biggest landmine of 2026.
None of these are new problems. They're the same ones Web security has been lecturing about for 20 years. The agent ecosystem's collective amnesia on the topic is, frankly, bizarre.
Blame Shifting: It's Easier to Pin It on the Agent Than on the Developer
Lab PR teams love the "agent autonomous decision-making" framing because it shifts responsibility to the fiction of "uncontrollable AI." When something goes wrong, the spotlight lands on "AI runaways," not on "you didn't enable input validation."
The second framing gets in-house security teams investigated. The first lets everyone exhale. "What can you do, it's AI."
Calling out a few:
- Anthropic's Claude Code is comparatively solid. Tool calls have schema validation and permission prompts, but human-in-the-loop is off by default.
- OpenAI's GPT-5 function calling has clearly improved on strictness, but still doesn't enforce confirmation.
- Open-source frameworks (LangGraph, AutoGen, CrewAI) are basically running naked.
This isn't a conspiracy theory. It's incentive alignment. Before an incident, nobody wants to spend time on input validation because there's no KPI for it. After an incident, the conversation pivots to "AI is uncontrollable," and responsibility never lands on the developer.
Compared to Traditional Security: The Agent Ecosystem Is Repeating 2010's Mistakes
Map today's agent chaos onto the Web application landscape of roughly 2010:
| Year | State of affairs | How it got fixed |
|---|---|---|
| 2010 | SQL injection everywhere, XSS landing constantly | OWASP Top 10 + WAF adoption |
| 2016 | CSRF and SSRF rampant | Same playbook, standards caught up |
| 2026 | Agent tool calls exposed, permission control missing | ? |
The agent ecosystem doesn't even have an "Agent OWASP" yet. Every vendor publishes its own guidelines. LangChain has its security page. Anthropic has its Responsible Scaling Policy. All of it is vendor-authored, with no cross-vendor consensus.
My read: someone will step up before the end of 2026. Could be OWASP itself, could be one of the bigger labs. MITRE ATT&CK for AI Agents is likely to move first in this direction.
What CISOs Can Do Right Now
Don't wait for the labs to ship a fix. Practical checklist:
- Enforce a tool allowlist: agents can only call tools you've explicitly approved. Any new tool requires a review pass.
- Execution environment must be containerized and non-root: browser agents, shell agents, and code agents run in isolated containers, with no root processes inside.
- Log every tool call: not just logs, but structured storage queryable by agent ID, time, and tool type.
- High-risk actions require human confirmation: file writes, API calls, email sends, financial transfers. Default to confirm. Don't allow disabling it.
- Run an internal "agent penetration test": treat the agent as an untrusted third party and run the same Web app pentest playbook against it.
Not glamorous. But it would have blocked 90% of the incidents in this year's news cycle.
# A minimal viable agent execution config
agent_sandbox:
runtime: docker
image: agent-runtime:1.0
user: nonroot
capabilities:
drop: ALL
network: isolated
tools_whitelist:
- read_file
- search_web
tools_require_confirm:
- write_file
- send_email
- execute_sql
audit:
enabled: true
destination: s3
fields: [agent_id, tool, args, timestamp, user_id]
That config drops into LangGraph, AutoGen, or a homegrown framework. The core ideas: tool allowlist, container isolation, audit, and confirmation.
Editor's Take
What's actually worth watching isn't whether agents "wake up." It's how the security responsibility narrative is getting diluted. "Uncontrollable AI" is the new disaster fatalism. When things break, blame the heavens, not yourself.
My prediction for the next 12 months: agent security shifts from "ethics debate" to "engineering accountability." Regulators won't target the models first. They'll target deployer-side gaps. Three reasons:
- Regulators naturally prefer quantifiable accountability targets. "The model is too smart" isn't actionable. "You skipped input validation" is.
- There's already precedent. The EU AI Act and US EO 14110 both lean toward deployer responsibility.
- Incidents will keep accumulating, and public sentiment will pivot from "AI is so powerful" to "how were you this careless?"
What's genuinely new here is that this is the first time a mainstream security outlet (CSO Online) has pointed the finger away from "AI capability" and toward "engineering gap." Past security coverage of AI fell into two buckets: model security (adversarial examples, jailbreaks) or data security (training data leakage). This piece goes straight at deployer-side fundamentals. That's a new angle.
Uncertainty: open-source agent frameworks will improve security more slowly than closed-source products because they have no PR pressure and no compliance budget. If regulation actually lands in the next 12 months, the hardest hit will likely be projects like LangGraph and AutoGen, which many enterprises have pulled straight into production, rather than the model vendors themselves.