Analysis · Apr 2026

The Core Mismatch

The paper describes one-agent, multi-user chaos — a single AI attempting to serve multiple users with conflicting needs, roles, and permissions, with no structural separation. What AUX assumes instead: a multi-actor, governed system — a structured, role-aware, policy-governed architecture where every participant is explicitly modeled.

Why Current LLM Setups Fail

Because they are:

  • Stateless — or poorly stateful, with no persistent understanding of context across sessions
  • Role-agnostic — no awareness of who is speaking or what authority they hold
  • Objective-confused — unable to reconcile competing goals from different users
  • Memory-leaky — data bleeds across users and sessions without structural boundaries
  • Not designed for organisational context — built for individual use, not for teams, hierarchies, or governed workflows

How AUX Architecture Solves This

AUX doesn't treat this as a "prompt problem." It treats it as a system design problem. The solution is architectural — not a matter of better instructions, but of better structure.

1. From "One Agent" to System of Actors

You don't design "an AI" — you design a collaboration topology. Instead of User A + User B + User C all talking to one AI, you get: CEO (actor), Engineer (actor), Agent (actor), Policies (context), Trust gates (control). The system knows who is who.

2. Role Awareness as a First-Class Primitive

Roles are explicitly modelled as Actors. Each actor has capabilities (what they can do), permissions (what they can access), and a trust profile (the level of authority and autonomy granted). Instead of guessing "Is this CEO important?", the system knows: Actor: CEO, Authority: high, Write permissions: global.

3. Privacy Through Context Blocks

AUX treats knowledge as structured, scoped context. HR data is attached only to the HR actor. Sales data is scoped to Sales. Personal notes are visible only to the individual actor who owns them. Instead of "don't leak this in the prompt" — the agent literally cannot access this context. Structural enforcement, not behavioural hope.

4. Conflict Resolution Through Trust Topology

When the CEO wants to stop a deployment and the Engineer wants to continue, the system doesn't "reason harder." It follows designed rules: the conflict triggers a Trust Gate, which escalates to the CTO with a structured decision moment.

5. Trust Gates for Decision Structure

Instead of the model deciding, the system forces a decision structure. Trust gates define what happens when the answer is "no" — with explicit escalation paths, authority hierarchies, and confirmation flows.

6. Coordination as Designed Scenarios

AI struggles with coordination (like scheduling). AUX treats coordination as a designed scenario: Actor A provides availability, Actor B provides constraints, Agent synthesises, Trust Gate confirms. Modelled as sequential flows, conditional branches, and parallel processes.

7. Structured, Persistent, Scoped Memory

Memory is not a blob. It is tied to the actor (no bleed across identities), tied to the process (not floating globally), and governed by access rules (who can read, write, or edit is explicitly controlled).

8. Organisational Awareness via Org Map

This is completely missing in current AI systems. The Org Map shows where agents live and what they connect to — who owns what, which agent serves which process, and where conflicts originate.

9. Trust Evolution

The paper assumes static behaviour. AUX introduces a Trust Timeline that evolves through stages:

  1. Functional: Ask for confirmation, show reasoning
  2. Contextual: Understands organisational nuance
  3. Judgment: Act autonomously, reduce friction
  4. Advocacy: Proactively represents actor interests

10. Intent Alignment via Intent Handshake

Instead of acting immediately on conflicting instructions, the agent surfaces the ambiguity: "Here's what I understand: CEO wants stop, Engineer wants continue. Proposed plan: Pause deployment pending decision. Approve / modify?"

The Meta Insight

The paper assumes AI is the decision maker. AUX reframes: AI is a participant in a governed system.

The Real Architecture Shift

The AUX paradigm replaces the single unstructured pipeline with:

  • Actors: Role-aware participants with defined capabilities, permissions, and trust profiles
  • Context: Structured, scoped knowledge blocks with explicit access boundaries
  • Trust Rules: Designed governance logic that resolves conflict without relying on model reasoning
  • Flows: Sequential, conditional, and parallel coordination scenarios explicitly modelled
  • Memory: Persistent, actor-tied, process-scoped, and access-governed
  • Org Structure: A map of where agents live, what they connect to, and who owns what

The result: a governed agent system.