SO:AI — Semantic Optimization for Agentic AI

Eleven dimensions. Each one traces a specific agentic AI failure back to the exact sentence in your design that causes it.

What you probably already have

Most agentic AI setups rely on some combination of these. Each one is valid. None of them covers what SO:AI audits.

Prompt engineering
Covers: instruction clarity, output format, tone.
Doesn't reach
Frame activation, speech act disambiguation, presupposition failures, among others.
System prompt guidelines
Covers: policy scope, behavioral rules, prohibited actions.
Doesn't reach
Deictic anchoring, enunciative polyphony, multi-turn coherence drift.
Templates & frameworks
Covers: structure, reusability, baseline consistency.
Doesn't reach
Domain-specific polysemy, semantic hedging failures, conceptual frame mismatches.
Schema markup & Knowledge Graph
Covers: entity definition, structured data, relationships.
Doesn't reach
Agentic execution logic, speech act triggers, authority and deixis in workflows.
AI governance policies
Covers: compliance, oversight, accountability frameworks.
Doesn't reach
Semantic precision of the policies themselves - a policy that is linguistically ambiguous fails regardless of intent.
Testing & red-teaming
Covers: edge case discovery, adversarial inputs, output validation.
Doesn't reach
Systematic diagnosis of why failures occur. Tests surface symptoms.

The methodology: What SO:AI detects

11

Diagnostic dimensions. Each one corresponds to a category of semantic failure that appears consistently across agentic AI systems - regardless of platform, model, or stack.

They're not checklists. Each dimension identifies a specific type of language problem, what it looks like when it fails, and what to change to fix it.

Some dimension diagnostics

Frame semantics
The agent acts as if it has authority it doesn't have.

A system prompt says the agent "selects the appropriate tool based on what you describe." The actual mechanism requires explicit human invocation. That one sentence activates a frame of autonomous agency the agent doesn't have - and it sometimes acts as though it does. The failure isn't in the tool. It's in the sentence.

Speech acts
The agent executes what was only mentioned.

Write-capable integrations are globally enabled - email, task management, messaging. No component defines when the agent can act versus when it can only respond. A user mentions needing to send a report. Nothing in the design distinguishes mentioning a task from requesting its execution. The agentic AI sends the message. The user mentioned the task - they didn't request execution.

Deixis
The agent speaks in someone else's name without knowing it.

A customer-facing agent drafts responses in the first person, signed with a real name. The workflow never asks whose name. "I'm reaching out to you directly" is published without the design ever establishing whose "I" that is.

Why this requires linguistics

Agentic AI doesn't execute logic. It interprets language. The failures above are not bugs in the code - they are failures in how meaning is structured and communicated.

These failure patterns have been studied in linguistics for decades - under different names, but with the same underlying mechanics. How a sentence frames a situation. How a word implies an action. How 'I' establishes a speaker. SO:AI applies that body of knowledge systematically to agentic AI design.

The people who built LLMs understood linguistics. Transformer architectures, attention mechanisms, tokenization - none of that was designed in ignorance of how language works. The knowledge gap is not in the models. It's in the automations built on top of these LLMs.

Most teams building AI automations put all the emphasis on connections, model selection, and an input prompt - then rely on the model's own inference to handle what wasn't designed. For simple automations, that sometimes holds. For anything with real semantic complexity, it doesn't.

Anyone building an automation who can't recognize a frame activation failure can't fix it - because they can't see it. Applied linguistics training is what makes these failure patterns visible and nameable.

And what's nameable is fixable.