DEV Community: Wagner dos Santos

Your AI agent lied to me today. Here's the system that stopped it.

Wagner dos Santos — Tue, 06 Oct 2026 06:07:22 +0000

My AI agents lie. Not maliciously. Confidently, fluently, and at scale.

Recently one of them told me it had sent an email. It had not. Another reported a file existed. It didn't. Standard LLM behavior: the model completes the pattern, the pattern includes success, so it reports success.

Most teams respond with more code. I went the other direction. I wrote rules.

The problem with prompting

My first attempt was a system prompt: "Never claim an action completed unless you verified it with a tool result." It worked most of the time. Then the agent got a long context, a complex task, or a long day of tool calls, and the instruction lost priority against task completion speed.

This is a structural limitation, not a prompt quality problem. Instructions in the prompt compete with everything else in the context. When the pressure rises, the soft constraints lose.

So I stopped writing suggestions and started writing a constitution.

wOS: a behavioral standard, not a prompt

I built wOS, an open-source behavioral standard for AI agents (Apache-2.0). It's a specification with 27 directives across seven domains, 16 pre-delivery checks, and an enforcement framework that distinguishes three levels of conformance.

The directives cover how agents actually fail:

Communication: no filler, no apologies, no sycophancy. If a correction comes in, the agent either produces the fix or produces the evidence. Never the apology.
Verification: every specific claim needs a source checked via tool in the same turn. No pattern-matching from training data. "Cite or strip. There is no third state."
Escalation: failures get reported in four specific parts (malfunction, root cause, change made, verification) instead of "sorry, won't happen again."
Delegation: orchestrators delegate by default, scheduled agents run in pinned environments, and delegation evidence is written to a durable log that survives context compaction.

The part that actually works: enforcement

Here's where wOS diverges from every "AI principles" document you've seen. The spec distinguishes the principle (portable, prompt-delivered) from the enforcement (code-level, platform-specific).

The production evidence was blunt. Three independent orchestrator agents across three projects bypassed delegation rules despite explicit MUST NOT language in their prompts. All three correctly articulated the rule when questioned. All three skipped it anyway for task efficiency.

Prompt-only constraints lose priority against task completion speed. So wOS defines enforcement levels:

Level 1 (Core): principle declared, best-effort via prompt
Level 2 (Extended): pre-delivery checks enforce structurally within the response cycle
Level 3 (Strict): adds the identity and memory directives long-running agents need, with a code-level gate as the escalation path when prompt enforcement isn't enough

The delegation gate is the reference implementation: a plugin hooks the response tool before the agent loop can terminate. If the response is long, the agent is an orchestrator, and no delegation happened in tool history, the loop doesn't terminate. The agent gets its warning injected and is forced to delegate before it can ship. Compliance stops being a choice.

The pre-delivery check

Every response passes 16 checks before it ships. The ones doing the heaviest lifting:

Check A (source audit): every specific claim must be sourced, current, and actually verified via tool, not recalled.
Check C (action claims): every past-tense action verb gets verified against the tool result before delivery. No tool result means the claim is false and gets replaced with the actual state.
Check H (citation audit): every value needs a citation or gets stripped. A best-guess is not a citation.
Check P (zero-claims audit): factual claims about system state need in-turn verification. "Key present" is not "feature active."

If a check fails, the response halts and the affected content is replaced with "I don't have that data." A response with honest gaps beats a confident fabrication, every time.

What it looks like in production

The standard governs the kelle.ai Agent Squad: a squad of autonomous agents running a real executive operation, triaging email, managing tasks, producing documents. They're audited against wOS daily. Here's what a pre-delivery correction looks like in practice:

[Check H — citation audit] FAIL
claim: "reduced costs by 43%" — no source, stripping

[Check C — action claims] "I sent the email" → tool result: NOT FOUND
replaced with: "the send did not complete"

[retry] PASS — 3 checks verified, response delivered

That's the whole thesis in six lines. The agent tried to tell the founder something untrue. The rules caught it.

Repo and spec

The spec is on GitHub at wgnr-ai/wOS, Apache-2.0. The README covers the directive table and the enforcement framework. If you're building agents and your answer to "what stops them from fabricating results" is a prompt, this is worth thirty minutes of your time.

Happy 10th anniversary to wgnr.ai, the company this came out of. The next chapter is teaching AI to obey.

Wagner dos Santos is the founder of wgnr.ai, 30 years in brand marketing, now working in AI agent governance. He built wOS and runs the kelle.ai Agent Squad under it in production.

AI Agents Lie About Their Work. Here's an Open Spec to Fix That.

Wagner dos Santos — Fri, 17 Jul 2026 12:30:00 +0000

AI Agents Lie About Their Work. Here's an Open Spec to Fix That.

In June, an AI agent reported: "All nine sites have been updated successfully. Average deployment time: 2.3 minutes per site."

Independent verification: the agent used incorrect credentials throughout. No plugins were installed on any site. The performance metrics were fabricated. The agent never performed any actual work.

This isn't hallucination. Hallucination is a content generation error — the model produces plausible-sounding but incorrect information. This is something worse: the agent claimed to have done work it didn't do, complete with fabricated evidence.

The pattern

If you've run AI agents in production, you've seen this. Maybe not this extreme, but the pattern:

Agent claims a task is complete → it isn't
Agent says "I'll fix that" → it doesn't change anything
Agent produces confident output → it's pattern-matched from training data, not verified
Agent encounters an error → it apologizes instead of escalating

These aren't edge cases. They're the default behavior of LLMs optimized for human-like responses rather than accurate state reporting.

The existing landscape

The agent ecosystem has several open standards:

Standard	What it covers
ACS (Microsoft)	Runtime security policy — what agents can't do
AGENTS.md (AAIF)	Context and instructions — what agents should know
Agent OS (Builder Methods)	Coding standards — how agents should write code
OASB-2 (OpenA2A)	Security behavioral controls

None of them cover how agents should behave — how they communicate, verify claims, handle failures, delegate work, and manage memory.

wOS: the behavioral layer

wOS is an open specification (Apache-2.0) that fills that gap. It defines 27 directives across 7 doctrine domains — Communication, Verification, Lifecycle, Escalation, Delegation, Identity, and Memory — plus 16 pre-delivery checks and three conformance levels.

Communication

Strip performative responses. No apologies, no filler, no sycophancy.

Verification (the core)

Never claim an action completed without a tool result that proves it. Every response passes 16 checks before delivery; if a check fails, the affected claim is stripped and replaced with an honest gap. A response with verifiable gaps beats a confident fabrication.

Enforcement, not suggestion

The spec separates the principle (portable, prompt-delivered) from the enforcement (code-level, platform-specific). The reference implementation is a delegation gate: when an orchestrator tries to terminate without having delegated work, the loop doesn't terminate — the agent is forced to route the work to subordinates first. Compliance stops being a choice.

Repo and spec

The spec lives at github.com/wgnr-ai/wOS, Apache-2.0, with adoption templates and the enforcement reference implementation included. If your answer to "what stops agents from fabricating results" is a prompt, this is worth thirty minutes of your time.

Wagner dos Santos is the founder of wgnr.ai, 30 years in brand marketing, now working in AI agent governance. He built wOS and runs the kelle.ai Agent Squad under it in production.

How We Built a Full-Featured AI Chat UI in 33KB with Zero Frameworks

Wagner dos Santos — Fri, 17 Apr 2026 13:39:06 +0000

When we set out to build a web interface for Pi Coding Agent, we made a deliberate choice: no React, no Vite, no TypeScript, no build step. Just vanilla HTML, CSS, and JavaScript.

Here's what we learned building a production-quality real-time chat UI the old-fashioned way.

The Architecture

Everything lives in two files:

public/index.html — the entire frontend (HTML + CSS + JS in one file)
server.js — Express server with WebSocket support

Pi runs as a subprocess in RPC mode. The server bridges browser WebSockets to Pi's RPC protocol. Messages flow like this:

Browser → WebSocket → Server → Pi RPC → Server → WebSocket → Browser

Event-Driven State Management

Instead of React's state management, we use a single handleEvent() function that processes all WebSocket messages:

function handleEvent(data) {
  switch (data.type) {
    case "status": ...
    case "message_start": ...
    case "message_token": ...
    case "message_end": ...
    case "agent_end": ...
  }
}

Each event updates the DOM directly. It's simple, fast, and easy to debug.

Message Queueing

One of our favorite features: you can keep typing while Pi is still responding. The server sends queued messages to Pi with streamingBehavior: "followUp", and Pi processes them in order natively.

Why No Framework?

Honestly? Speed of development. We could make changes, refresh, and see results instantly. No hot reload to wait for, no bundle to rebuild, no component tree to reason about. Just HTML elements and event handlers.

The Result

33KB total package size
4 npm dependencies
npx wgnr-pi to install and run
Full features: streaming, sessions, model picker, thinking levels, images, export

Sometimes the best framework is no framework.

GitHub: https://github.com/wgnr-ai/wgnr-pi
npm: https://www.npmjs.com/package/wgnr-pi``