OrgLM.ai / OMAP
Open Memory & Action Protocol
OMAP defines the messages exchanged at the boundaries of a governed enterprise AI system — the shape of a retrieved fact, of a proposed action, of a request to a model. It says nothing about how a conforming system works inside.
§0 · Status and Scope
This is a public, open specification. It defines the messages a governed system exchanges at its edges, and deliberately says nothing about how a conforming system stores, ranks, learns from, or reasons over information.
The keywords MUST, SHOULD, and MAY are used in the conventional sense. A system is OMAP-conforming if it satisfies the requirements in §4–§7; it is free to satisfy them in any way it chooses.
Nothing here reveals how any particular system achieves conformance. Confidence appears as a number in a field; provenance as an opaque handle; policy as an accept-or-reject decision. The engines that produce those values are out of scope by design. You can build against OMAP without learning anything about how anyone has built to it.
§1 · The Problem
A frontier model is, for any given organization, a rented brain — brilliant and borrowed. Its accumulated knowledge, its rules for how decisions are made, its memory, and its accountability cannot be relocated into a third party's weights.
The prevailing pattern wires a model straight to a vector store and a set of tools and trusts prompt engineering to hold the line. That arrangement fails in four specific, recurring ways — none of them a model-quality problem, none solved by a better model. They are architectural: properties of where the boundaries are drawn.
Context fetched as undifferentiated text loses its kind, its eligibility, and its source. There is no clean boundary to audit.
Rules buried in a prompt or a model's training cannot be versioned, reviewed, or proven. They drift with every change.
Knowledge that lives only in a context window is gone when the request ends. The organization accumulates nothing.
Welding to a single vendor makes that vendor's pricing, availability, and roadmap load-bearing. A deprecation becomes an outage.
Keep four things on the organization's side of the boundary: typed retrieval, explicit policy, durable memory, and model-independence.
§2 · Requirements
Independent of any implementation, the four failures impose four requirements. OMAP exists to encode exactly these, and nothing more.
Every fact crossing into a model carries a type, a provenance handle, and a confidence value — so it can be filtered, audited, and traced.
Every proposed action is a structured request that an explicit policy gate accepts or rejects before anything happens.
The boundary to the model is a structured contract, not a text channel, so models can be swapped without changing the surrounding system.
Confidence and escalation are first-class fields, so the system can know — and signal — when an answer is not good enough.
How a system computes a type, derives a confidence value, or makes a policy decision is entirely out of scope. The contract specifies the envelope; the substrate is a black box.
§3 · Participants
A single deployment MAY collapse several roles into one process. OMAP only constrains the messages, never the packaging.
Surface
The user- or agent-facing application. Consumes typed facts and proposes actions. Knows nothing about which model answered.
Substrate
The system that holds and retrieves the organization's information and enforces policy. Treated as a black box. An OrgLM.ai implementation plays this role; OMAP neither requires nor describes it.
Model endpoint
Any model — open-weights or frontier — reached through a pluggable model-access layer. Receives structured requests, returns structured results.
Policy gate
The decision point that accepts or rejects facts and actions against the organization's explicit, versioned rules. Returns a verdict, never a rationale a model can override.
§4 · The Typed-Fact Envelope
A fact is the unit a substrate returns and a model consumes. Every fact MUST carry the following fields. The contract constrains their presence and meaning, not how their values are produced.
// the unit a substrate returns and a model consumes Fact { type : string // namespaced kind, e.g. "account.summary" payload : object // structured content; schema keyed by type provenance : handle // opaque, resolvable reference to source confidence : number // 0.0–1.0; meaning is monotonic only policy_tags : string[] // labels the policy gate may act on as_of : string // ISO-8601 time the fact was valid }
type, payload, provenance, and confidence.policy_tags and as_of.provenance as eligible to influence a governed action.OMAP requires only that confidence be a value in [0,1] whose ordering is meaningful: higher means more trustworthy. How that number is derived is intentionally unspecified. Two conforming substrates may compute it completely differently and remain interoperable.
§5 · The Governed-Action Contract
When a surface, agent, or model wants to do something — send an email, write to a system of record, trigger a workflow — it emits an ActionRequest and waits for a Verdict from the policy gate.
ActionRequest { action : string // namespaced verb, e.g. "crm.write" arguments : object // structured; schema keyed by action basis : handle[] // provenance handles justifying the action proposer : string // surface | model | agent identifier } Verdict { decision : enum // ALLOW | DENY | ALLOW_WITH_EDITS edits : object? // present only for ALLOW_WITH_EDITS policy_ref : string // version of the ruleset that decided }
ActionRequest MUST receive exactly one Verdict before execution.Verdict MUST cite the policy_ref that produced it, so any decision is reproducible against a known ruleset version.DENY, and MUST honor edits on ALLOW_WITH_EDITS without renegotiation.The contract says nothing about how the gate decides — the ruleset, its language, and its evaluation engine are implementation concerns. OMAP guarantees only that a decision exists, is explicit, and is attributable to a version.
§6 · The Model-Access Interface
This is the interface that makes models interchangeable. A request carries typed facts and a task; the response carries a result and an honest signal about whether the chosen model was sufficient.
ModelRequest { task : string // namespaced, e.g. "draft.reply" facts : Fact[] // typed inputs (§4) constraints : object // output schema, limits, format tier_hint : enum? // LOCAL | FRONTIER — advisory only } ModelResult { output : object // conforms to constraints confidence : number // 0.0–1.0 (same semantics as Fact) escalate : bool // true ⇒ caller SHOULD route higher model_ref : string // which endpoint answered }
ModelRequest to any conforming endpoint and receive a schema-valid ModelResult.tier_hint is advisory: a router MAY default to an open-weights endpoint and reserve frontier endpoints for tasks where confidence falls short or escalate is set.escalate when it cannot meet constraints, rather than returning a low-quality result silently.Because request and result are structured contracts rather than text, an open-weights model and a frontier model are addressed identically. The organization routes by task and by honest confidence — open-weights by default, frontier when the work demands it — and swapping either side changes nothing above this interface.
§7 · Conformance
A system is OMAP-conforming if and only if:
Every fact it emits across a boundary is a valid Typed-Fact Envelope (§4);
Every action it executes was preceded by exactly one Verdict from a policy gate, attributable to a policy_ref (§5);
Every model it invokes is reached through the Model-Access Interface, such that the endpoint can be substituted without changes above the interface (§6);
It honors the confidence and escalate signals rather than discarding them.
A system may use any storage, any ranking method, any learning mechanism, and any reasoning approach behind these contracts and remain fully conforming. That is the point: the protocol is open precisely because it commits to nothing about the substrate.
Reference · JSON Schema
The three envelopes as JSON Schema (draft 2020-12). Drop them into a validator and you are conforming at the boundary. Everything behind it is yours.
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"$id": "https://orglm.ai/omap/fact.schema.json",
"title": "Fact",
"type": "object",
"required": ["type", "payload", "provenance", "confidence"],
"properties": {
"type": { "type": "string", "pattern": "^[a-z0-9_]+(\\.[a-z0-9_]+)+$" },
"payload": { "type": "object" },
"provenance": { "type": "string", "minLength": 1 },
"confidence": { "type": "number", "minimum": 0, "maximum": 1 },
"policy_tags": { "type": "array", "items": { "type": "string" } },
"as_of": { "type": "string", "format": "date-time" }
},
"additionalProperties": false
}
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"$id": "https://orglm.ai/omap/action.schema.json",
"$defs": {
"ActionRequest": {
"type": "object",
"required": ["action", "arguments", "basis", "proposer"],
"properties": {
"action": { "type": "string", "pattern": "^[a-z0-9_]+(\\.[a-z0-9_]+)+$" },
"arguments": { "type": "object" },
"basis": { "type": "array", "items": { "type": "string" } },
"proposer": { "type": "string" }
},
"additionalProperties": false
},
"Verdict": {
"type": "object",
"required": ["decision", "policy_ref"],
"properties": {
"decision": { "enum": ["ALLOW", "DENY", "ALLOW_WITH_EDITS"] },
"edits": { "type": "object" },
"policy_ref": { "type": "string", "minLength": 1 }
},
"additionalProperties": false
}
}
}
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"$id": "https://orglm.ai/omap/model.schema.json",
"$defs": {
"ModelRequest": {
"type": "object",
"required": ["task", "facts", "constraints"],
"properties": {
"task": { "type": "string" },
"facts": { "type": "array", "items": { "$ref": "fact.schema.json" } },
"constraints": { "type": "object" },
"tier_hint": { "enum": ["LOCAL", "FRONTIER"] }
},
"additionalProperties": false
},
"ModelResult": {
"type": "object",
"required": ["output", "confidence", "escalate", "model_ref"],
"properties": {
"output": { "type": "object" },
"confidence": { "type": "number", "minimum": 0, "maximum": 1 },
"escalate": { "type": "boolean" },
"model_ref": { "type": "string" }
},
"additionalProperties": false
}
}
}
OMAP v0.1 is a public draft. The schemas above are normative for the envelopes they define; everything behind the contract is left, deliberately and permanently, to the implementer.