Dispatches from the
agentic frontier
News, analysis, and insights from the world of agentic experience design. Stay ahead of the shift from tools to trusted collaborators.
No dispatches in this category yet.
What Is Agent Operability — and Why Your Enterprise Needs It
auxfirst introduces agent operability: the capacity of a specific workflow to be performed by an AI agent with bounded autonomy, usable context, explicit decision rights, and reconstructable accountability. Why pilots keep dying in security review (the death spiral in seven steps), the three-layer model — data shape, process design, trust & permissions — a five-question self-check you can run today, plus the free field guide at agentoperability.com and the fixed-price Agent Operability Audit.
Execution Got Cheap. Trust Didn't.
Three June-2026 studies and two same-day design publications point at one structural change: cheap execution relocates the human — from doing to directing, and from trusting output to verifying provenance. The delegation economics (26 minutes of autonomous work vs 33 seconds of search), the expertise multiplier (humans keep ~70% of planning decisions), why complexity sliders fail (46% compliance), and the four design imperatives mapped onto the AUX components that answer them. With a 60-second verification test for teams shipping agents.
AI Models Have Formed Beliefs About Your Brand. We Built the Instrument That Reads Them.
Launching the Agentic Shelf Audit: a fixed-price, ten-day audit of everything AI models assert about a brand — every belief graded (accurate to fabricated), traced to its sources, and turned into an influence roadmap. With findings from a composite sample battery — 52 queries, four models, 418 transcripts: a Belief Integrity Score of 58/100, a false allergen claim delivered as safety advice, and a study that doesn't exist. Starts with a free 3-belief teaser.
The 40th Principle: Who Verifies the Other 39?
Taras Bakusevych's "39 Principles for Designing Human–AI Interaction" is the best applied synthesis of the field to date — model specs as design canon, sycophancy as a design problem, provenance over confidence. But every principle assumes a human on the other side of the glass, and that assumption is expiring. Two blind spots — the agent as the user, and principles without proof — with a mirror table, the EU AI Act mapping, and the 40th principle the field needs: make conformance verifiable.
AI @ Santander: The Good, the Bad, and the Ugly
A bank open-sourced its AI lab — fourteen Apache-2.0 repositories, none mentioning agentic experience design, which makes them an honest X-ray of how a regulated institution thinks about trusting machines. Read through an AUX lens: the good (mechanical governance, provenance, bounded mutation), the bad (almost no dry-run, a client that omits a confidence signal), and the ugly (an agent-runner that ships every guardrail off by default). With a scorecard and the lesson underneath: you learn a team's trust model from its defaults, not its framework.
Process Brains: Why You Need Them and How to Build Them
Most teams use AI; far fewer have turned it into anything that compounds. A process brain is a small, governed machine that captures how one job should be done and does it the same way, every time. The four parts of a brain, why prompting doesn't compound, and how to choose between a lightweight, heavy-duty, or multibrain system — with a comparison table and the order to build them in.
The Agents Got Jobs — What YC's Spring 2026 Batch Reveals
Go down YC's Spring 2026 list — just under 200 companies — and the overwhelming majority aren't building assistants that talk; they're building agents that act. The unit of value moved from seats to outcomes, and the design problem from screens to consequences: identity, permission, spend, evidence, escalation, liability. A field note that maps the batch onto the agentic-design questions — with a comparison of who's solving what.
Open-vs-Closed Is a Procurement Question, Not a Trust Question
US labs vs Chinese labs, open weights vs closed APIs — the loudest argument in AI is a scoreboard, and for anyone shipping agents it's the wrong one. The model is the most swappable part of the stack. The durable questions: which model for which task, inside which guardrails, with what proof. With a model-lineup comparison and the "narrowed, not closed" benchmark.
Eve Makes Agents Legible. It Doesn't Make Them Accountable.
Vercel's Eve makes an agent a directory of files and ships the production machinery — durable runs, sandbox, approvals, traces, evals. It makes agents legible; it doesn't make them accountable. That evidence-to-attestation gap, across a separating five-layer stack, is exactly where AUX lives. The companion to the Vercel reclassification.
The Agent Buyer's Map
A new procurement category — AI agents — with no Magic Quadrant and no shared buyer vocabulary, so every vendor ships an evaluation framework built to flatter its own agent. The independent, buyer-side answer: ten dimensions, one number, one vocabulary across every vendor. Score it live on the page; print the one-pager.
Can I Prove What the Agent Did?
Jamin Ball says the clearinghouse wins the agent era — and Microsoft is already shipping it. But for a brand, "prove what the agent did" fractures into four questions a permission log can't answer: who authored it, is it on-brand, is it brand-safe, and did a human genuinely sign off. The source of trust is a different layer.
Cites or Escalates — Designing a Compliance-Grade Policy Agent
Every certified company has the same gap: the policies exist, but nobody can use them. How to design an ISO 27001 policy agent under contract — closed world, a citation on every claim, escalation to a named human the moment the source goes silent. Nine files, eight brains, zero write access.
A Safe Agent Isn't a Trusted One
Agent trust is two problems, not one. Machine safety is standardizing in the open — table stakes within a year or two. Whether a human can understand, steer, recover, and rely on an agent over time is a separate discipline: Agentic User Experience, and the real moat.
Agent Enablement — The Operational Layer
Your agents aren't underperforming because the model is weak. They're underperforming because everything around them — context, tools, playbooks, feedback — was never built. The four pillars, a toolbox, and a maturity ladder.
The Two-Layer Stack: AUX Above Microsoft's Agent Governance Toolkit
Microsoft just shipped the deterministic enforcement layer for autonomous agents. AGT makes the agent incapable of misbehaving. AUX makes the user willing to keep using it. Both necessary. Neither sufficient. Here's how they stack.
Agent-First API Design — The New Developer Experience
For thirty years, API-first meant designing for human developers. In the agentic era, the primary consumer of your API is an autonomous system. Six principles, a CRM worked example, and a ten-point checklist for the new DX.
What Is Agentic User Experience (AUX)?
The AUX Start Pack — manifesto, six foundational patterns, eight principles, ten heuristics, a four-stage trust architecture, and TrustKit. Everything a team needs to design for agents, memory, and trust.
Advertising Agencies Are About to Hit the Agentic Trust Crisis
AI is moving from generation to delegation. Most agencies are not ready for the question that follows: can we trust this agent to act inside this workflow, for this client, without damaging the brand?
Launching Auxfirst on GitHub: Introducing TrustKit
We're launching Auxfirst on GitHub and introducing TrustKit — a foundational trust abstraction layer for AI agents, distributed systems, and verifiable communication between services.
10 Heuristics for Agentic Experience
A visual reference for the 10 core heuristics of AUX design — covering trust, autonomy, memory, transparency, and control. Download and use as a design checklist or team alignment tool.
Agentic User Experience
Understanding the next interface paradigm. Software is shifting from tools you operate to systems that act, agents that decide, and software that works for you. The unit of interaction is no longer a click — it's an intention.
AUX Examples: Structured Agent Flows
Eight real-world AUX examples covering sales, support, fitness, developer tools, GTM, finance, onboarding, and content — each demonstrating intent handshakes, progressive autonomy, and trust design.
Beyond Greedy Reasoning: An AUX Framework for Long-Horizon Agent Reliability
Step-by-step reasoning behaves like a greedy local policy. Long-horizon reliability needs explicit lookahead, backward value propagation, and limited commitment with replanning — solved experientially through AUX.
Designing Agentic User Experiences (AUX)
From desired outcomes to AX to spec and production system. A complete design methodology covering trust layers, six design primitives, interaction patterns, and three implementation approaches.
The Core Mismatch
One-agent multi-user chaos vs. what AUX assumes: a multi-actor, governed system. How AUX architecture solves the fundamental problems of role-agnosticism, memory leaks, and conflict resolution in current LLM setups.