Open Framework — MIT License

Layered Agent Architecture
for governed AI workers.

LAA is an open orchestration pattern. It defines how a single governing component — the orchestrator — maintains coherence, memory, and governance across a heterogeneous set of agents operating on different platforms, in different domains, with different internal architectures.

What has value and cannot be reproduced is the relationship of trust. Human to human, human to AI — it does not matter. What matters is apprehending and documenting that trust relationship.

View on GitHubRead the whitepaper
THE PROBLEM

Agents without governance are just scripts with opinions.

Most agent frameworks optimize for execution. LAA optimizes for trust. Capability is necessary but not sufficient — what determines whether a human actually uses an agent is fit: does this agent understand how I work, what I care about, when to act and when to ask?

WITHOUT LAA
  • Each agent decides on its own — no coherent governance across the system.
  • Memory is a fact store. No trust levels, no provenance, no freshness rules.
  • Autonomy is configured, not earned. The user carries the risk.
  • No exploration mode — agents execute or fail, no co-reasoning with the human.
  • No delegation model — implicit cost-benefit evaluation stays invisible.
WITH LAA
  • One orchestrator governs. Workers execute. Structural separation.
  • Memory Contract with 4 confidence levels: inferred, validated, rejected, abandoned.
  • Autonomy is earned through demonstrated reliability — calibrated over time.
  • Exploration Mode — agents co-reason, hold abandoned paths, signal contradictions.
  • Explicit delegation — reversibility, trust risk, and resource pressure are visible.
THE 7-LAYER FRAMEWORK

Seven layers. One governing component.

The 7 layers do not describe how every agent must be built. They describe what the orchestrator must implement in full. The core (1–4) is immutable. Layers 5–6 are dynamic. Layer 7 belongs to the orchestrator only.

1IdentityImmutable. Name, mission, tone, scope, position in the system. If all modules are disabled, identity remains coherent on its own.Core
2CapabilitiesDeclarative action surface. What the agent CAN do — not what it MUST do. The Module Registry is the source of truth.Core
3PolicyGovernance layer. Autonomy thresholds, escalation rules, conflict resolution, token budgets, decision arbitration primitives.Core
4Memory ContractState with governance: trust levels, freshness, provenance, temporal horizon. Owned exclusively by the orchestrator.Core
5BehaviorsLocal, contextual reactions. Volatile and interchangeable. Loaded dynamically via Module Registry. Cannot modify layers 1–4.Dynamic
6StrategiesLong-term goals and arbitration across sessions. Preserve trust over speed. Minimize friction. Favor progressive delegation.Dynamic
7Feedback LoopsCybernetic regulator with cross-worker visibility. Proposes behavioral rules. Collects anonymized platform signals. Orchestrator only.Orchestrator only
INTEGRATION ENTRY POINT

Level 0 Worker Contract

The minimum contract any non-LAA worker can return to integrate with the orchestrator. 6 fields. No architecture change required.

// Minimum contract for any non-LAA worker
{
  "worker_id":          "string",
  "action_performed":   "string",
  "reversible":         true | false,
  "resource_consumed":  { "tokens": 0, "cost_eur": 0.0 },
  "outcome":            "success | partial | failed",
  "confidence":         0.0 – 1.0
}

reversible feeds the autonomy engine. resource_consumed feeds budget governance. outcome + confidence feed trust calibration over time. side_effects allow reasoning about cascading actions.

DESIGN PRINCIPLES

Core design principles

01
Orchestrator is structural
Without a dedicated orchestrator, there is no LAA implementation. There is only a collection of agents.
02
Workers execute, orchestrator governs
An execution-optimized component cannot simultaneously govern, detect drift, and protect the non-expert user.
03
Trust over capability
Humans delegate based on trust, not capability. LAA is the first agent framework built around this principle.
04
Conformance is incremental
LAA adoption is a gradient. Each level delivers immediate value. You don’t need full conformance to benefit.
05
Exploration is a first-class mode
Agents don’t just execute — they co-reason. Exploration Mode holds abandoned paths, signals contradictions, and maps the reasoning terrain.
06
Delegation is calibrated
Every action is implicitly evaluated: autonomy cost, trust risk, reversibility, resource pressure, expected utility. Trust is earned, one decision at a time.
CONFORMANCE GRADIENT

Start wherever you are.

LAA adoption is incremental. Each level delivers immediate value. No store required. No shared infrastructure required.

LEVEL 0
Orchestrator only
Workers are black boxes. Memory Contract fed from external observation. Coherent ecosystem, basic governance.
LEVEL 1
Mixed conformance
Some workers expose log_interaction signals. Memory Contract partially fed from inside. Higher signal quality.
LEVEL 2
Full conformance
All workers expose structured signals. Memory Contract fully fed. Feedback loops at full capacity. Self-calibrating system.

Integration example

// LangChain agent — no architecture change
result = langchain_agent.run(task)
return {
  worker_id: "my-langchain-agent",
  action_performed: task,
  reversible: false,
  resource_consumed: { tokens: result.usage.tokens, cost_eur: result.usage.cost },
  outcome: "success",
  confidence: 0.8
}

"In a world where AI makes every output cheap, the scarce resource is proven human connection. What becomes scarce and valuable is the proven trust between a specific human and their agent ecosystem."

— LAA Specification, v1.3

RESOURCES

Resources

WHITEPAPER

The full LAA specification — framework, memory contract, feedback loops, economic governance, and portability model.

Download PDF →
GitHub

MIT-licensed. Reference specification, the whitepaper, and the AI-readable llms.txt format.

View repository →

Built on LAA: Klair.work — the first multi-tenant platform implementing LAA across all its professional AI workers.