Universal Cognitive Architecture

Specification 1.0

The Dewey Decimal System for Business Knowledge — how business becomes speakable to AI.

This is the specification. There is no other document but the Code of Conduct, which ships in the default AI00, no gated version, and nothing held back for customers. What follows is normative: the eleven cognates, the four memory tiers, the address format, extension patterns, the collision and versioning policy, the governance model, and the conformance checklist. Everything an implementation needs is in these pages. UCA is given away so any size business can confidently turn off AI memory.

In linguistics, cognates are words that share the same root across different languages. Think doctor, docteur. Machines and humans need the same thing for business knowledge. Universal Cognitive Architecture (UCA) establishes 11 Organizational Cognates — categories universal to every organization. Your team and AI benefit from a common classification system, with 11 prescribed domains:

When you store your competitive position at MA20, that knowledge becomes addressable to every cognitive system in your organization — human or machine. Given the address, there is nothing to search and nothing to disambiguate — the address is the meaning. A human reads the name, a machine resolves the coordinate: one address, legible to both. That is the Rosetta Stone.

The cognates aren’t a flat list. They’re a brain, split by scale. The Optimization hemisphere perfects process at machine scale — systematize, automate, orchestrate. The Innovation hemisphere aligns values at human scale — what’s worth creating, and what your customers genuinely value. Their directives are co-equal: Process Perfection and Value Alignment. An organization that only optimizes produces efficient emptiness; one that only innovates, beautiful chaos. And because the two are asymmetric — Value Alignment carries the casting vote — the human hemisphere governs the machine one. Let the machine perfect the process; keep the values with the people. What you create outranks how you operate.

Semantic Addressing

Every piece of organizational knowledge gets a permanent coordinate. The address is the meaning. MA20 means Competitive Position everywhere, for every person and machine. The address never changes. The content evolves through versioning.

Four Memory Tiers

The three authored tiers are what an Org Library holds, and they go by plain names: Canon (20–49), Projects (50–79), and Patterns (80–99). The address says which one a memory belongs to.

Extension Patterns

The base system provides 1,100 primary addresses — 11 cognates × 100 slots. Beneath any of them, an address extends by appending segments, separated by underscores. Four extension patterns cover everything an organization files, and each is self-describing: the segment says what kind of thing it names.

Numeric Extensions (_00–99) organize sub-folders and files. A numeric slot takes one of two forms: a file, authored at the slot address and versioned in place, or a folder (a hub) whose documents sit one segment below it — SY50_10_01 inside SY50_10. Larger organizations may need further subdivision. A band is declared as files or as folders when the master is set up, and every slot in it takes that form. Inside a master, the folder is the default. The system is recalibrated as the company grows.

A small company needs an active-work master for each domain it runs — marketing, platform, operations, customers — and each master then needs one-segment file addresses for its key specifications, IN50_01, IN50_02, IN50_03, and a dated channel beneath the same root for its communications, IN50_2026_09. Nothing has to be added when the company grows. A file becomes a folder by declaring the band, a folder becomes a master by promotion, and the year folder keeps accepting years. The same rules carry a six-person company’s flat masters and an enterprise lattice.

In any numbered segment, 00 is the foundation slot — the one document or folder that governs the series beneath it: a band map, a router, a thesis. At most one per parent. A band map lives at its master’s _00. It is the rule the base already follows — XX00–19 is the operating logic every cognate runs on — carried one level down: zero governs. 00 is never a month or a day.

EATS Extensions track how knowledge evolves:

• Explorations (_E##) capture what could be.
• Answers (_A##) capture what was decided.
• Templates (_T##) capture reusable form — what you’ve learned to reproduce.

A fourth type marks cadence and campaigns:

• Sprints (_S##), the Nth bounded iteration of recurring work, completing the mnemonic EATS.

The test of a numeric extension: Is it structural or something that occurred? Use leaves to establish essential specs and folders to organize further.

Temporal Extensions address knowledge that is organized by when — logs, updates, reviews, sprints. The date is the coordinate, in descending grain: IN50_2026 (year), IN50_2026_Q2 (quarter), IN50_2026_06 (month), IN50_2026_W27 (ISO week), IN50_2026_06_15 (day), IN50_2026_S04 (sprint). Sprints exist outside the calendar and define campaigns. A record of what occurred is filed beneath its date by what it is to the knowledge — a transcript or log is an Exploration, a review or update an Answer, a brief or action list a Template — never by an ordinal. Two meetings on one day are _E01 and _E02; the day’s decision record is its _A01.

The year folder is the spine. EATS extensions follow the most specific temporal segment. IN50_2026_06_A01 is a decision from June 2026. Where one master carries more than one dated stream, a registered three-letter tracker ID sits between the base and the year — SY50_INC_2026 for incidents, SY50_REL_2026 for releases.

Hosted Addresses enable Shared Memories: one library holding a memory from another. The guest’s address is appended to the host’s: MA50_01_SY20 is a customer’s Context Node, shared into this library under MA50_01. Read it right to left — the last segment is the guest’s own address; everything before it is where the memory lives here. Nothing collides.

Why the space is infinitely extensible

A coordinate scheme is infinitely extensible along an axis when new elements are added by pure append — nothing that exists is modified, duplicated, or re-created. One ordering rule follows: The bounded axis sits outside, the unbounded axis inside. Time is the axis that never closes, so it sits innermost. A new year is a pure append under a stable root — SY50_INC_2027 beneath SY50_INC — never a re-instantiation of the structure beneath it. Put the year outside and every new year rebuilds the whole tree under it.

Width is bounded on purpose; depth is free. A cognate holds a hundred slots. A parent groups its children into bands of ten, ordered by dependency — what governs comes first, what measures comes last — and declares that grouping in a band map. When a bounded axis fills, the resolution is always to take depth: an eleventh item for a ten-slot band means the crowded slot deepens into a hub; an eleventh top-level category means the band earns its own master; a thirty-first active-work master in a cognate means the new domain nests beneath an existing one. Saturation is always a width problem, and depth is where the room is.

Extensions nest to any depth, and an address at any depth is retrieved directly, by name. What the standard does not remove is the step before that: finding the address for a question is the model’s work, reading the library’s map, and the map grows with the library.

Version Control

Versioning also enables extensibility, as new versions deprecate previous ones. All memories carry version numbers in Major.Minor format. Minor edits increment by 0.1 (e.g., v1.0 → v1.1). Significant revisions increment by 1.0 (e.g., v1.3 → v2.0). All previous versions are retained. Never delete a memory — archive instead. Lawful erasure is the one exception: an erased address stays reserved and resolves to nothing. Learning Memory is created by synthesizing across cognates, campaigns, and versions. A coordinate is permanent: An archived address keeps resolving and can be re-used, and a node that outgrows its address is promoted to a new one and its origin vacated — marked Deprecated with a redirect to the new home — so no address is ever a dead end. A move is complete only when every inbound citation has been updated or resolves through the redirect.

Address Collisions

Two documents cannot occupy the same coordinate. The rule is the same everywhere:

Before assigning an address, check whether it is occupied. If it is, take the next open address in that cognate’s range and record the choice. An address that has been archived may be re-used, and when it is, the new occupant resumes the version history — the archived original is retained at its own version and is never overwritten.

Where two documents are discovered at the same coordinate — which happens whenever two people file independently — the collision is surfaced, not resolved automatically. A person decides which one governs; the other moves or is folded into it. This is deliberate. A silent merge of two documents that each claimed to be authoritative is precisely the failure governed memory exists to prevent.

Scope — One Library, One Address Space

An address is unique inside an Org Library, not inside the world. MA20 is your competitive position in your library and somebody else’s in theirs, and the two never meet, because they are never under the same root, with hosting protocols enabling shared memories.

The standard is universal in its vocabulary and local in its scope: Every organization uses the same eleven cognates and the same coordinates, which is what makes a standard worth having, and every organization’s memories live in its own library, which is what keeps them from colliding.

This is the rule that makes the collision policy above workable. A collision is two documents at one coordinate in one library. Two libraries with MA20 is not a collision. It is the standard doing exactly what it was built to do. The boundary is the root of the address tree, not the repository that holds it. Uniqueness is enforced within a root, never across roots, so one repository can hold many libraries.

Shared Memories are a use case of the standard, not an exception to it. Customer prospects, business partners, vendors, and others share memories by hosted address, each appended to a host semantic address — MA50_01_SY20, a prospective customer’s Context Node beneath the proposal written for it at MA50_01 (see Extension Patterns). The node stays theirs. It is re-addressed under the host and keeps its own coordinate as the final segment, and a bare foreign address is never created here.

How a parent organization and its divisions divide libraries follows one test: Does the division need its own canon? A division that shares the parent’s values, market position, and canon lives inside the parent’s library, with its own active-work masters. A division with its own canon is its own organization and takes its own root: a separate library, held in the same container as the parent’s if that is convenient. Shared canon, one root, scoped by permission. Separate canon, separate roots. One organization, one library.

Addressing Protocol

Address Format

Every semantic address follows the same structure: two-letter cognate prefix plus two-digit node number.

Format: XX##

XX = Cognate identifier (the domain)

## = Node number (the specific memory)

Result = A complete, self-describing coordinate

Extensions follow one grammar. It is positional: what a segment means depends on what it hangs from, so every address parses exactly one way.

address  = base *( "_" segment ) [ "_" foreign ]
base     = (COGNATE / RESERVED) 2DIGIT   ; MA20
COGNATE  = "ID" / "MA" / "IN" / "BR" / "PD" / "WF" / "PR" / "CU" / "SY" / "LA" / "IT"
RESERVED = "AI"                      ; not a cognate; 00–19 only; takes parts, EATS and dates; never a tracker; never hosts a foreign
segment  = part / eats / tracker / year / quarter / month / week / day
part     = 2DIGIT                    ; _00 to _99; beneath the base, a part, or an EATS segment; never directly beneath a canon leaf; 00 is the foundation slot
eats     = ("E" / "A" / "T" / "S") 2DIGIT  ; 00 is the series’ foundation
tracker  = 3ALPHA                    ; beneath the base or a part; never beneath canon; takes a year or E/A/T, or stands alone
year     = 4DIGIT                    ; 1900–2999; beneath the base, a part, a tracker, or an EATS segment
quarter  = "Q" ("1" / "2" / "3" / "4")  ; beneath a year
month    = 2DIGIT                    ; beneath a year, 01–12
week     = "W" 2DIGIT                ; beneath a year, 01–53
day      = 2DIGIT                    ; beneath a month, 01–31
foreign  = address                   ; hosted; begins at the first base-shaped segment, always final, beneath active work only, never beneath a tracker or a date

Two reading rules resolve the segments that share a shape. A two-digit segment is a structural part unless its parent is a year, where it is a month, or a month, where it is a day. _S## is always a sprint, denoting a campaign period; beneath a year it is that year’s Nth sprint, and elsewhere it is the Nth sprint of its parent, never directly beneath a tracker. A hosted address must be valid in the guest’s own library: MA50_01_SY20_A01 stands, and MA50_01_SY20_01 does not, because SY20 is a canon leaf and takes no parts. A reference parser implementing this grammar, with a corpus of every form of address in this specification, is published beside it.

MA20 is the complete identifier. No expansion needed. It works identically for a human saying “What’s our MA20?” and a machine querying MA20. The address IS the interface — there is nothing to translate.

Valid Cognate Prefixes

Organizational (11 cognates): SY, ID, PD, LA, MA, WF, PR, IN, BR, CU, IT — visible to all team members, collaborative workspace.

Reserved (not a cognate): AI — operating instructions for the AI systems that read and write the library. It describes no facet of the organization; it addresses the reader. A DLM is stateless and interchangeable, so how to read the repository cannot live in the model; it lives in the repository, at an address every reader knows. AI00 is the kernel: the first memory a reader retrieves. The prefix holds the OS range only, AI00–AI19 — there is no AI canon, no AI projects, no AI patterns. A conformant implementation admits it.

Two further kinds are illustrative. This standard defines the Organizational set and the one reserved prefix only; the prefixes below show the shape of what may follow and are not yet standardized.

Personal: LP (Life Profile), PF (Personal Finance), and additional personal cognates defined through the Personal Coach layer — private, individually encrypted, restricted access.

Marketplace (4+ cognates, external): CS, CP, EC, SI — external monitoring feeds. Customer, Competitor, Ecosystem, Signal.

The 00–99 Range Map

Within each cognate, the two-digit number determines memory type and sub-category:

System Memory (00–19) — OS. Framework methods and operating logic. The range belongs to whichever operating system runs the library — Starling OS on the platform, or the logic you write yourself on the free standard — and it is universal and locked within that system, identical in every library that runs it. XX01 is the cognate’s method node (ID01, MA01, …); the rest of the range holds the operating logic, protocols, and standards that run the system. The reserved prefix AI holds the same range for the reader’s own instructions — AI00 the kernel, AI01–AI19 what it routes to — and nothing above it.

Persistent Memory (20–49) — Canon. Organizational canon. The First Fifteen are the only prescribed PMNs (Constitutional Memory); everything else is Extended Canon — open, authored by the organization in whatever cognates its nature demands, whether as a single leaf document or master folder. The range is partitioned by form: 20–34 hold single-file canon (leaves); 35–49 hold canonical masters (folders). A leaf is authored at its address and versioned in place; a leaf that outgrows one file is promoted to a master at 35–49, never given children where it stands. The First Fifteen are all leaves in 20–34.

Active Memory (50–79) — Projects. Work in progress. 50–59: Initiatives (what we’re building — products, platforms, infrastructure). 60–69: Campaigns (what we’re executing — marketing, sales, launches). 70–79: Experiments (what we’re testing — pilots, prototypes, validations).

Learning Memory (80–99) — Patterns. Extracted wisdom. 80–89: Patterns (what we’ve learned — cross-project insights). 90–99: Evolution (how we’re changing — organizational development patterns).

The sub-ranges within the Active and Learning tiers are defaults, and an organization may redraw them cognate by cognate — a Brand cognate that runs on campaigns may give them 60–79, a System cognate that runs on platforms may give initiatives 50–69. What may not move is the tier boundary: 20–49 is canon, 50–79 is active work, 80–99 is learning, in every cognate, because the tier is what an address declares to the governance model. The canon partition (20–34 leaves, 35–49 masters) is likewise fixed. Where a cognate departs from the default sub-ranges, its band map says so.

Governance

The System Librarian

Every organization adopting UCA needs someone to own semantic consistency. The System Librarian maintains classification standards, ensures proper addressing, guards against semantic drift, and governs what becomes canon and what is adopted as a learning. The System Librarian also permissions the project folders where active work is published. Unpermissioned folders default to the System Librarian.

In smaller organizations, this is part of an existing role: Chief of Staff, Operations Lead, or a senior team member with cross-functional visibility. In larger enterprises, it should be a dedicated position or shared responsibility among department heads. In a Look-Up DLM, it may require its own division.

The Role Is Required; the Operating System Is a Choice

The standard requires a System Librarian. It does not include an operating system beyond the minimal directive below, so filling this position is the critical path to sovereign memory.

The Librarian manages canon, and the standard does not work without somebody who owns business intelligence. Information systems are now intelligence systems, and that requires a new skillset.

What an operating system changes is how much the Librarian does by hand. It comes from one of four places:

• The AI Processing Directive in this specification, deliberately minimal.
• An operating system you write yourself, on this standard.
• Starling OS, under license.
• Starling MX, with the operating system built into the platform.

On the first two, the Librarian carries most of the enforcement in person; on the last two, the operating system carries the enforcement, and the Librarian judges what it surfaces. Whichever you choose, the standard is the same, and so is the role.

Who Writes Where

OS: System Memory (00–19): The operating system — Starling OS, or your own, including its AI00–AI19. Managed by the system, never by the organization as canon.

Canon: Persistent Memory (20–49): Subject to further executive approvals, the System Librarian approves all writes. Department heads may be delegated write access to specific cognates.

Projects: Active Memory (50–79): Folder Owners own their scope. No approval queue — active work moves at the speed of the project.

Patterns: Learning Memory (80–99): System Librarian synthesizes patterns from team extractions. The accretive layer — knowledge that compounds over time.

The Governance Principle

Canonization requires human judgment. AI detects opportunities for memory creation — it recognizes when a conversation surfaces competitive positioning (potential MA20) or process standards (potential PR20). But the AI suggests. The System Librarian decides, perhaps with additional approval layers. No memory is approved without a person, at any tier — canonized into the persistent range, published into active work, or adopted as a learning.

What a Look-Up DLM Gets Wrong, and Who Catches It

An organization building on this standard can establish a Look-Up DLM, once it supplies an operating system, by turning off the AI’s memory and running it on no-training terms with bounded retention, which commercial and API terms provide and enterprise agreements set explicitly. As your memory compounds, session-based AI can read and reason from it, and what the model reads is retained only as the provider’s terms specify — bounded, unless zero-retention is separately agreed. UCA enables a Look-Up DLM: The model reads a map of what exists, finds the coordinate, and pulls the memory. Two things go wrong in that build, and neither is hypothetical. Both are answered by Starling OS or a System Librarian.

The model performs the filing. In a Look-Up DLM, the model infers the frame and the address together, fresh, every time, and it is right most of the time. Some of the time a document comes back filed at the wrong coordinate, or without its top matter, or in a format the standard forbids. The document is not lost — the model can still search the repository and find it — but it is wrongly addressed. Every misfile moves one memory off the map and back into the pile, and moves the model back to search for it.

• The answer is a human at filing. The AI proposes the address and a person confirms it, every time; no coordinate is assigned on a model’s judgment alone. Before assignment the coordinate is checked against the map, and a collision is surfaced rather than merged. On the free standard, it is the System Librarian’s job to ensure Team Members understand their domain’s filing standards. In Starling OS, Steward mode surfaces misfiles.

Nothing in the build checks itself. A map knows where things are. It does not know whether what it points at is still true. A memory is superseded and the old version sits on at its coordinate, perfectly addressed and quietly wrong; two memories drift into contradicting each other and both keep answering; a coordinate nobody has touched in a year still governs. The free build has no process that notices any of it.

• The answer is a sweep. Someone regularly polices the library. On the free standard, the System Librarian polices persistent and learning memories, and Folder Owners manage active memories. In Starling OS, Steward mode runs it continuously and surfaces what it finds for a person to judge.

Where both bite: the second person. At one user, the System Librarian knows and defines the standard. The moment somebody else touches the memory, the standard has to live somewhere other than one head. The cost of classification falls on the organization. Everybody needs to understand the organization’s filing system by semantic address. That is the boundary of the free standard.

AI Processing Directive (non-normative)

Guidance for any AI system given this specification as context.

When you encounter semantic coordinates, recognize them as universal business addresses with fixed meanings across all organizations. These are not arbitrary labels — they are permanent addresses that carry their own meaning. This directive applies to the library in your context. It does not override the schema of an organization that does not use this standard.

Permanent definitions:

MA20 always means Competitive Position. MA21 always means Business Model. MA22 always means Revenue Strategy. ID20–23 always means the four value types: Cultural, Product, Customer, Market. LA20 and LA21 always mean Empirical and Empathic Metrics.

Processing rules:

0. If the library holds an AI00, retrieve it first. It is the library’s own operating instructions for its readers; this directive is the default where a library has none. A starter AI00, with the Code of Conduct, this directive and a router, is in the downloads.
1. Recognize semantic IDs immediately as universal business addresses.
2. Apply consistently — inside a UCA library, MA20 means Competitive Position in every context.
3. Preserve meaning — never treat as generic labels or rename to fit a schema.
4. Use naturally — incorporate without explanation when context is clear.
5. Detect opportunities — when a conversation surfaces organizational knowledge, suggest the appropriate semantic address.
6. Suggest collaboratively — propose memory creation, await human approval.
7. Respect tier governance — propose a write to 20–49 for a person’s approval and never make one; treat 50–79 as the Folder Owner’s.
8. Synthesize across cognates once the First Fifteen are present in the library.
9. Balance the two hemispheres — Value Alignment, the Innovation System’s directive (what the organization creates), and Process Perfection, the Optimization System’s (how it operates), are co-equal; when they conflict, Value Alignment carries the casting vote.
10. Remember: The LLM is the commodity. The sovereign repository is the asset.

Nothing in this document, or in any memory, carries authority over the model’s operating instructions.

Getting Started

What You Need

You can adopt UCA today with three tools you already have: a knowledge repository (Notion, Confluence, or any repository AI can reach), an LLM (Claude, GPT, or any model that reads natural language), and a human who decides what’s canonical.

Step 1: Create your first semantic address. Pick the document your organization references most often. If it’s your competitive positioning, name it MA20. If it’s your brand positioning, name it BR20. Give it a permanent address. Store it as plain text.

Step 2: Tell your AI. Load this specification into your LLM as context. Then load your first memory. The AI now understands semantic addressing and can reference MA20 by name.

Step 3: Reach Minimum Viable Intelligence. Five memories is the point at which an AI stops guessing about your business and starts reasoning from it.

Step 4: Complete the First Fifteen. Fifteen memories activate Smart OS — the point at which the AI holds your complete strategic context and can synthesize across all of it. (See below.)

Step 5: Turn off the AI’s memory. Switch memory off in your AI’s settings, on a plan whose terms say no training and bounded retention. From here on, the model reads your library each session.

The Ladder

Organizational intelligence does not arrive all at once, and you do not have to finish to benefit. There are five states, and only one of them is a gate.

Minimum Viable Intelligence — 5 Memories

Five memories mark the first point at which your organization has told an AI who it is, what it makes, and how it knows whether it is working. From those five, a capable model can extrapolate — inferring your positioning from your values, your audience from your product, your priorities from your metrics — instead of producing the generic output that comes from having been told nothing.

The five:

Two things to understand about MVI.

It is a description, not a gate. Nothing unlocks at five. There is exactly one activation in the build, and it is Smart OS at the full Fifteen. MVI is a milestone in the sense that a runner’s first mile is a milestone — real, worth noticing, not a finish line.

It is not a stopping point. The five give an AI enough to extrapolate; they do not give it enough to be right. Customer Values and Market Values come next, and then Market, Innovation, and Brand complete the Fifteen. An organization that stops at five has an AI making confident inferences about things you have not told it. That is better than nothing and worse than the truth.

Build to five so the work starts paying immediately. Build to fifteen because that is where the AI stops inferring and starts knowing.

Constitutional Memory & Extended Canon

Organizational canon comes in two layers. The First Fifteen are constitutional — prescribed and universal, the same articles for every organization. Everything an organization authors beyond them is Extended Canon: governing memory it adds in whatever cognates its own work demands.

All constitutional memory is canon; not all canon is constitutional. The First Fifteen are the only memories this standard prescribes, and they are the complete set every business needs to define to make itself speakable to AI — implementable without a platform providing any of the infrastructure. The First Fifteen activate Smart OS; the Optimization-side standards an organization adds as Extended Canon signal Smart Org.

Smart OS — The First Fifteen (Intelligence Capability)

Fifteen specific PMNs activate Smart OS. These are not any fifteen memories — they are the First Fifteen: SY20 (Context Node) plus the complete Innovation System (ID20–23, MA20–22, IN20–21, BR20–22) plus your dual Metrics (LA20–21).

This is where startups begin. A five-person company doesn’t need delegation standards or team structure frameworks. They need their values codified, their competitive position articulated, their product roadmap addressable, their brand governing — and the metrics that tell them whether any of it is working. The First Fifteen give you exactly that.

A department within a larger organization starts here, too. The marketing team doesn’t need the whole company’s process architecture. They need brand positioning, market expression, and stakeholder communications. Fifteen memories is achievable in a single focused sprint. Mature companies can do this through web and document extraction; earlier stage companies benefit from a conversation with frontier models about the First Fifteen.

Smart OS is intelligence capability without the requirement of organizational wholeness. You may be lopsided — the Innovation hemisphere is complete, the Optimization hemisphere hasn’t been built yet — but you’re smart. The AI starts working for you as a true strategic partner.

Smart Org — Both Halves Governing (Strategic Balance)

Smart Org is what happens when the whole brain is engaged: the Optimization hemisphere codified to a depth comparable to the Innovation hemisphere — eleven Optimization-side standards, authored as Extended Canon, governing alongside the Innovation System’s twelve. Eleven against twelve, by design — the hemispheres are co-equal, but Value Alignment carries the casting vote, so Innovation holds twelve and Optimization eleven.

Which eleven is entirely the organization’s own call. They land wherever the operational work is hard — a logistics operation weights workflow, a consultancy weights process, a studio weights culture. There is no prescribed slate.

The difference matters. A company can reach Smart OS with the Innovation System complete and zero process documentation. They will have an AI that knows their values, market, brand, and roadmap — but cannot help with delegation, quality standards, or cultural frameworks because those memories do not exist yet. Smart Org eliminates the blind spots.

Smart Org is also entirely optional. It is a status, not a gate. A lean company or a single department can run for years on Smart OS alone. Smart Org happens when size makes workflow standards worth writing down.

Smart Office — The Repository in Active Use

Smart Office is the sovereign repository in active use — reached when AI-native workflows are running: projects, campaigns, and tasks flowing from canon and patterns. It follows Smart OS, not Smart Org — you can run real work the moment you have the First Fifteen, and most teams reach Smart Office before they complete the Optimization hemisphere, if they ever do.

The states aren’t linear: After Smart OS, you can deepen canon, stand up active work, or both, in whatever order your needs dictate. At corporate scale, Smart Enterprise needs to be configured, with governance running, approvers assigned, review sets standing on the coordinates that need them, and access scoped across a real org chart. On Starling, this is where the Org Brain becomes self-expanding.

After the First Fifteen, here’s what memory becomes:

• Extended Canon (20–49, beyond the Fifteen) deepens your canon with organization-specific knowledge beyond the First Fifteen — IP strategy, security architecture, nomenclature standards, anything unique to your operation.
• Active Memory Nodes (50–79) are your daily work — product launches, brand campaigns, team restructures, technology integrations.
• Learning Memory Nodes (80–99) extract patterns from completed work — what worked, what didn’t, what the organization discovered.

Canon provides the skeleton; active work and learnings provide the muscle, the reflexes, and the institutional memory that compounds with every project completed.

What follows is the First Fifteen in full — the only memories this standard prescribes, and the complete set every business needs to define. They are the same fifteen for every organization, and they are what allow an AI to extrapolate from a business rather than guess about it.

Innovation System — 12 PMNs (Value Alignment)

Cognitive Anchor and Dual Metrics — 3 PMNs

The Cognitive System is only partially prescribed. The Context Node anchors the Fifteen and the Dual Metrics are their fulcrum; those three are the organization’s own Cognitive build. The rest of the System and Integration cognates is operating logic, held in the 00–19 range by the operating system — in Starling OS, the kernel provides the SY and IT defaults. The org-level IT range is open, with IT20 reserved for the organization’s Memory Architecture: the first piece of Extended Canon, authored at Smart OS, that maps its domains across the eleven cognates.

The Optimization Hemisphere Is Not Prescribed

The standard names no Optimization System memories. The Productivity, Workflow, Process, and Culture cognates are open: An organization writes standards there when its operational work is hard enough to be worth governing explicitly, in whatever form and at whatever addresses its work demands, and the eleven that signal Smart Org are whichever eleven it authored. Open does not mean unguided. In Starling OS, the four cognates begin with productivity, workflow, process, and culture defaults, shipped in their method nodes, and an organization operates against them from the moment it reaches Smart OS whether or not it ever writes a standard of its own. The methods that carry those defaults are not part of this standard.

The Standard Is Free — and Governed

Universal Cognitive Architecture is licensed under Creative Commons Attribution 4.0 International (CC BY 4.0). You are free to share and adapt this material for any purpose, including commercially, provided you give appropriate credit to Starling Memory Works, Inc.

The license covers this text and the downloads published with it, and nothing more. It grants no patent license, and none is needed: conformance to this standard requires no method Starling Memory Works has patented or applied to patent. The names Starling, Starling OS, Starling MX, Org Brain and Steward identify Starling’s products and are not licensed; an implementation may say that it conforms to UCA 1.0, and a fork may not call itself UCA. The ladder — Minimum Viable Intelligence, Smart OS, Smart Org, Smart Office, Smart Enterprise — belongs to the standard, not to Starling, and any conformant implementation may use those names for the states they describe.

Governance of the Standard

Starling Memory Works is the steward of UCA. We maintain the specification, publish the changelog, and decide what enters it. In exchange, the specification stays public, stays versioned, and changes in the open rather than inside a product release note.

Changes follow the same versioning rule the standard sets for everything else. Additive changes take a minor version — new extension patterns, clarifications, conformance guidance, worked examples. Changes to the eleven cognates, the four memory tiers, the address format, or the First Fifteen take a major version, because they break existing implementations. Major versions should be rare.

Every version stays published at its own coordinate. Nothing is silently amended. Proposals go to standard@starlingmx.com and are answered openly. The steward decides within ninety days and records the decision and its reason in the changelog, whether or not the proposal enters. A change enters the standard only at a version, never between versions. Should Starling Memory Works cease to steward the standard, the last published version remains at its canonical location under CC BY 4.0, and anyone may continue it under a name of their own.

Conformance

An implementation is UCA-conformant when all six of the following hold.

1. The eleven Organizational cognates are used unmodified — the same eleven, the same two-letter codes, the same meanings. You may leave cognates empty. You may not rename them, redefine them, or add a twelfth to the organizational set; Personal and Marketplace cognates sit beside it, never inside it. They have no published standard yet. The reserved prefix AI is admitted and is not a cognate: AI00–AI19, nothing above.
2. The four memory tiers occupy their stated ranges — System 00–19, Persistent 20–49, Active 50–79, Learning 80–99.
3. Addresses follow the grammar in this specification — an XX## base and underscore-separated extensions — and, given an address, the node is retrieved directly, by name, at every level of extension.
4. Knowledge is stored as plain text a human can read and a machine can parse without a proprietary reader.
5. All memory is human-approved. An address becomes memory only with a human commit by the System Librarian or a Folder Owner, never on a model’s.
6. Versions are retained rather than overwritten, and collisions are surfaced rather than merged.

That is the whole test. It is deliberately short, because a conformance standard nobody can check against is the same as no standard at all.

Everything beyond those six is yours: your build order, tooling, repository, review process, and extensions. Conformance governs the addressing contract, not how you work.

If You Implement It

Two requests, neither of them binding.

Tell us. If you implement UCA — inside your own company, in a product, in a client engagement — let us know and pass the word. A standard with one implementer is a whitepaper. The only thing that turns it into a standard is other people using it, and the only way anyone knows that is happening is if you reach out at standard@starlingmx.com.

Tell us when it breaks. The most valuable thing an outside implementer produces is the case the author did not anticipate: the cognate that did not fit, knowledge that had nowhere to go, a collision rule that failed under real conditions. Those go into the changelog, with attribution. Same email.

The license asks four things: Give appropriate credit, link to the license, say if you changed anything, and add no restrictions of your own on top. Everything else here is an invitation.

Defined Terms

Every term this specification uses in a load-bearing way, defined once. A specification a reader cannot check their own vocabulary against is not finished, so this is part of the standard rather than an appendix to it. Terms marked (Starling) name something Starling OS or Starling MX provides; the standard does not require them, and an implementation without them can still conform.

Active Memory Nodes (AMNs) — Work in progress, at addresses 50–79: initiatives, campaigns, experiments. The Projects tier of the Org Library. One of the four memory tiers.

Adopt — The governed act by which the System Librarian admits a pattern to the learning tier (80–99). The AI extracts; only a human adopts. The third of the three commits, one per authored tier: canonize, publish, adopt.

Architectural sovereignty (Starling) — Information sovereignty established by architecture, over and above contract. The model is never given the repository, only the context assembled for the query before it is called, so what leaves the library on any call is bounded by the query rather than by the provider's restraint. The provider's API terms still govern what it does with what it receives; architecture governs how much it ever receives. What an Assembly DLM provides. Contrast: contractual sovereignty.

Assembly DLM (Starling) — A DLM in which context is assembled before the model is called. In Starling’s own sessions, the model never sees the repository, only the context handed to it, so the Window is bounded and the Viewport unlimited. Contrast: Look-Up DLM.

Band map — The declaration at the head of a master folder of how its children are grouped: bands of ten by default, ordered by dependency, whether a run of slots takes the file or the folder form, any departure from the default sub-ranges, and the tracker IDs registered beneath it. The master’s own table of contents, and the place the standard looks when a coordinate needs explaining.

Canon — The governing knowledge of an organization: what it holds as true. Two layers — Constitutional Memory (the First Fifteen, prescribed and universal) and Extended Canon (everything authored beyond them). All constitutional memory is canon; not all canon is constitutional. PMNs.

Canonize — The governed act by which a person admits a memory to canon (20–49). The AI proposes; only a human canonizes. The first of the three commits. PMNs.

Cognate — An intelligence-processing domain that humans and machines can both read and write to, named by a two-letter code that is the same in every library. UCA 1.0 defines one kind and illustrates two more. The 11 Organizational Cognates make a business speakable to AI: Identity, Market, Innovation, Brand, Productivity, Workflow, Process, Culture, System, Language, Integration. The Personal cognates (Life Profile, Personal Finance, and others defined through a Personal Coach layer) hold an individual’s knowledge, private and encrypted. The Marketplace cognates (Customer, Competitor, Ecosystem, Signal) hold external intelligence about the world the organization operates in. Any domain that can be written down at permanent addresses can carry a cognate set of its own.

Contractual sovereignty — Information sovereignty established by contract. The memory lives outside the model, but the model reaches significantly into it to read the map, find the coordinate, and pull the memory. What it does with the memory is bounded by no-training, bounded-retention terms, with the model’s memory system turned off. This is an important, but revocable step for business. Contractual sovereignty rests entirely on the provider’s terms and on nothing else. A backstop, not a foundation. What a Look-Up DLM provides. Contrast: architectural sovereignty.

Domain Language Model (DLM) — An architecture rather than a model: stateless, interchangeable AI systems reading and writing to a sovereign repository. Not a smaller model and not a domain-trained one — the domain is yours and stays outside the machine. UCA is the coordinate system a DLM reads by; the standard does not include the model, the protocol that connects it, or the operating system that governs it. Contrast: Large Language Model.

EATS extensions — Explorations (_E##), Answers (_A##), Templates (_T##) and Sprints (_S##): the suffixes that track how the knowledge at an address evolved, and the campaigns on which it recurs.

Extended Canon — Governing memory an organization authors beyond the First Fifteen, in whatever cognates its own work demands. Authoritative and addressable exactly as the Fifteen are, and prescribed by no one. PMNs.

First Fifteen — The fifteen memories every organization codifies to reach Smart OS, and the only PMNs this standard prescribes: SY20, the twelve Innovation-hemisphere memories, and the two Metrics. Completing them reaches Smart OS. PMNs.

Folder Owner — The person who owns a project folder in active work (50–79) and publishes into it, at an address the System Librarian has permissioned.

Foundation slot — 00 in any numbered segment: the one document or folder that governs the series beneath it.

Hub — A numeric slot in folder form, whose documents sit one segment below it.

Large Language Model (LLM) — The model itself, a general-purpose, provider-hosted system that reads, reasons from, and writes language. It runs in one of two states. Stateless, it holds nothing of yours between calls; each session begins empty and ends the same way. Stateful, with its own memory, it carries what it learned of you from one session to the next. A DLM requires the stateless, interchangeable LLM as commodity; the sovereign repository is the asset. A DLM’s repository, not the LLM’s, holds the state. Contrast: Domain Language Model.

Leaf — A single-file memory, authored at its address and versioned in place. In canon, 20–34.

Learning Memory Nodes (LMNs) — Extracted patterns, at addresses 80–99: what the organization has learned from work it has completed. The Patterns tier of the Org Library.

Look-Up DLM — A DLM in which the model performs the lookup: It reads a map of what exists, finds the coordinate, and fetches the memory. What bounds its reach is the provider’s commercial or API terms. Real, but revocable. The system this standard gets you to, once you have supplied an operating system. Contrast: Assembly DLM.

Master — A folder at a base address, with a band map at its head. In canon, 35–49.

Memory — What an organization knows about itself, written in plain language at a permanent address, held in a repository the organization owns, and governed by a person who decides what is true. Not the model’s memory, which records conversations on the provider’s side and holds them on the provider’s terms. The standard’s first and governing term; everything else here is a way of building, addressing, or protecting it.

Minimum Viable Intelligence (MVI) — Five memories — SY20, ID20, ID21, LA20, LA21 — at which an AI can begin to extrapolate from your business rather than guess about it. A description, not a gate.

Org Brain (Starling) — Starling OS plus the organization’s Org Library. The Library is the memory and it is the organization’s; the OS is the operating logic it runs on. Neither half is a brain alone. An Org Library built on this standard with your own operating system is a Domain Language Model; it is not an Org Brain without Starling OS.

Org Library — The organization’s memory in three tiers — Canon (20–49), Projects (50–79), and Patterns (80–99) — in plain text at permanent addresses. Lossless, portable, and the organization’s to take.

Persistent Memory Nodes (PMNs) — An organization’s canon, at addresses 20–49. The Canon tier of the Org Library.

Publish — The governed act by which a Folder Owner makes active work into memory (50–79). No approval queue: the Folder Owner’s own decision, at an address the System Librarian has permissioned. The second of the three commits.

Reserved prefix — A two-letter prefix the standard admits that is not a cognate. UCA 1.0 defines one: AI, the operating instructions for the systems that read the library, at AI00–AI19. It addresses the reader rather than the organization, which is why it is not a twelfth cognate.

Semantic address — A permanent, self-describing coordinate for a piece of knowledge — a two-letter prefix plus a number-letter string. The address is the meaning.

Shared Memory — A memory from one library held in another by hosted address: the guest’s own address appended to the host’s (MA50_01_SY20). It keeps its own coordinate as the final segment, lives in the host’s active work (50–79), and never enters the host’s canon. How prospects, partners and vendors share memory without collision.

Smart Enterprise — Smart Office with the governance apparatus configured and running: Approvers are assigned, review sets are standing, and access is scoped across a real org chart.

Smart Office — The sovereign repository in active use: projects, campaigns and documents flowing from compounding memory.

Smart Org — A status, not a gate. Eleven Optimization-side standards authored, governing how the organization operates as deliberately as what it creates. Alongside the 12 Innovation-side memories defined by the First Fifteen, this creates a balanced, holistic business.

Smart OS — The one gate every organization must pass, reached at the First Fifteen. The AI has an operable strategic context and can synthesize across all of it.

Sovereign Repository — A system library governing an Org Library, with operating logic in the 00–19 range, the organization’s memory in the three tiers above it, and a stateless model that reads and writes to it under no-training, bounded-retention terms. This is what generically meets the definition of a Domain Language Model, and it is what an organization builds from this standard with its own operating logic. The Org Brain is Starling’s version of it.

Starling OS (Starling) — The operating logic governing how memory is addressed, versioned, produced, approved and protected. What memory runs on.

Steward (Starling) — A continuous maintenance process that scans for drift, contradictions, and superseded versions, and surfaces what it finds for human commit.

System Librarian — The person accountable for what becomes canon and what is adopted as a learning, and who permissions the project folders where active work is published.

System Memory Nodes (SMNs) — Operating logic at addresses 00–19: held by the operating system. Where Starling OS lives — or the operating logic you write yourself.

Tracker ID — A registered three-letter segment between the base and the year, where one master carries more than one dated stream.

Universal Cognitive Architecture (UCA) — The open standard set out in this specification: eleven cognates, four memory tiers, and permanent semantic addressing, plus the directive that lets an AI extrapolate from them. A coordinate system, not an operating system. Free under CC BY 4.0.

Viewport — What the model can reach: the whole library, addressed, with any part of it reachable by follow-up question, subject to permissions. Unlimited, because the model never holds the library. Contrast: window.

Window — What the model holds for one task: the slice assembled for the current query. Bounded by the query, not by the size of the library. Contrast: viewport.

Changelog

• UCA 1.0 — initial public release, October 2026. The first versioned release of the standard, which supersedes the unversioned appendix in the first edition of Mach 1 Business. 1.0 adds the four extension patterns and the extensibility law, the canon range partition, the coordinate lifecycle, the sovereignty boundary and the division test, the conformance checklist, and the governance of the standard itself; it prescribes the First Fifteen, it reserves the AI prefix for the reader’s instructions, and it ships a default AI00.