Field guides.

# Memorix Platform Overview — Developers **Audience:** Engineers integrating another product with Memorix (HTTP API or `@x12i/*` packages).

• Install (start here)
• How to read this guide
• The central mental model
• 1. What Memorix is
• 2. Architecture
• 3. Scope on every request
• 4. API families
• 5. Packages (when to use what)
• 6. The opx mental path end to end
• 7. Local stack (quick start)
• 8. Hard product rules (integrator checklist)
• 9. Forbidden (antipatterns)

# Memorix Format for Dummies **Audience:** Developers integrating solutions that read/write `memorix-record/2`.

• How to read this guide
• The central explanation
• 1. Memorix in five minutes
• 2. Anatomy of `memorix-record/2`
• 3. Subject identity and `recordId`
• 4. Object type, content type, and data category
• 5. The `concept` bucket
• 6. The `.data` bucket
• 7. `_system`, timestamps, and provenance
• 8. Revision and safe writes
• 9. Composition: same subject, different content
• 10. Discriminated content instances

# Memorix Runtime Data Client Guide **Audience:** Application, connector, agent-runtime, SDK, and script authors that call Memorix through the supported service boundary.

• How to read this guide
• The central mental model
• 1. Client mental model in practice
• 2. Connection and scope
• 3. Metadata discovery for runtime clients
• 4. Exact content reads
• 5. Listing and querying
• 6. Explicit composition
• 7. Abstract reads
• 8. Relationship reads
• 9. Concrete writes
• 10. Patch language

# Memorix Runtime Lists, Queries, Pagination & Bulk Access **Audience:** Developers whose clients retrieve or process **more than one** Memorix resource — content pages, abstract unions,…

• How to read this guide
• The central mental model
• 1. What “list” means here
• 2. Endpoint inventory (client-visible)
• 3. Common list response / `pageInfo` contract
• 4. Exact query grammar
• 5. Field-path rules
• 6. Missing, null, empty, and absent
• 7. Sorting
• 8. Cursor contract
• 9. Pagination guarantees
• 10. Page-size behavior

# Memorix Runtime Data Access Patterns **Audience:** Application, agent, connector, pipeline-step, Studio/UI, and operator-script developers choosing *which* runtime access method to use for a job.

• How to read this guide
• The central decision model
• 1. Client types and access style
• 2. Master decision matrix
• 3. Reading one known item (exact get)
• 4. Reading through lists
• 5. Exact read versus list
• 6. Composition versus multiple gets
• 7. Relationships versus list joins
• 8. Abstract versus concrete access
• 9. Metadata-defined views versus ad-hoc queries
• 10. Direct writes and the read-modify-write loop

# Metadata, Agents, Abstracts & Mappings — Developers **Audience:** Integrators authoring or consuming declarative Memorix metadata (packs, effective resolution, abstracts, mappings, custom kinds).

• How to read this guide
• The central mental model
• 1. Packages and HTTP surface
• 2. Pack shape (`memorix-metadata/1`)
• 3. Agents and inheritance
• 4. Object types and content types
• 5. Abstracts — virtual unions only
• 6. Mappings — deterministic transforms
• 7. Views, writes, and the client effective-metadata pattern
• 8. Built-in vs custom kinds
• 9. Install and publish — never auto
• 10. Ops narrative walkthrough

# Relationships & Memory — Developers **Audience:** Engineers working with four-field relationship links and source landing via Memory.

• How to read this guide
• The central mental model
• 1. Packages and HTTP surface
• 2. Memory — exact source landing
• 3. Relationships — four-field links only
• 4. Engine lifecycle — discover / verify / rebuild / cleanup
• 5. Reads — virtual expansion
• 6. Opx narrative walkthrough
• 7. Store details (Candidate C)
• 8. How Memory and Relationships relate to other planes
• 9. Hard rules (relationships & memory)
• 10. What not to do

# Building Memorix Services — Developers **Audience:** Service, connector, pipeline, agent-package, and AI-job developers.

• How to read this guide
• The central mental model
• 1. Do I need a service?
• 2. One model — roles catalog
• 3. Define the service
• 4. Implement the handler
• 5. Roles, one by one
• 6. Bind and deploy
• 7. Invoke from a pipeline
• 8. Data access — may and must-not
• 9. Secrets, validation, reliability
• 10. Testing

# Building Memorix Pipelines — Developers **Audience:** Pipeline authors, service developers, connector and AI-job developers, operators, and platform integrators.

• How to read this guide
• The central mental model
• 1. Pipeline definition
• 2. Execution model
• 3. Data movement
• 4. Step types, one by one
• 5. Pipeline patterns
• 6. Authoring process
• 7. Services inside pipelines
• 8. AI pipelines
• 9. Batches, concurrency, and writes
• 10. Operations

# Workflow & Studio — Developers **Audience:** Integrators calling workflow APIs or embedding Studio-adjacent host clients.

• How to read this guide
• The central mental model
• 1. Studio constraint (service-only UI)
• 2. Design · Operate · Explore (developer map)
• 3. Scope bar ≡ HTTP headers
• 4. Workflow is sibling content
• 5. Workflow HTTP (`/api/workflow`)
• 6. Ops narrative: WI-100 workflow edit
• 7. Embedding guidance for host apps
• 8. Relation to data plane and OpenAPI
• 9. Decision tree
• 10. Anti-patterns

# Structural Intelligence — Developers **Audience:** Engineers integrating structural profiling and evidence-backed metadata proposals.

• How to read this guide
• The central mental model
• 1. Package boundary
• 2. Deterministic profile first
• 3. Propose from evidence
• 4. Human install (the only write path)
• 5. Optional AI adapter (untrusted)
• 6. Ops narrative drill (employees / WI-100)
• 7. Embedding intelligence in a host
• 8. Evidence model (what proposals must carry)
• 9. Compare and export drafts
• 10. People-oriented suggestions

# Agent Packs & OpX — Developers **Audience:** Authors packaging metadata + fixtures for an agent, and engineers running opx acceptance.

• How to read this guide
• The central mental model
• 1. When to use the opx pack
• 2. Pack layout
• 3. Harness: up / down / reset / accept
• 4. Author a new agent pack (phased)
• 5. Custom kinds in a pack
• 6. Golden V2 validation
• 7. Install into a fresh acceptance org
• 8. Child agents and inheritance
• 9. Decision tree
• 10. Anti-patterns

# Building KnowX as a Memorix Agent Pack **Audience:** Developers implementing the first-party KnowX agent — vocabulary, services, and pipeline.

• How to read this tutorial
• The central mental model
• A — Vocabulary
• B — Service specs (Memorix contracts)
• C — Pipeline `knowx-ingest-associate`
• D — Install and sandbox run
• Human review (siblings)
• Checklist
• Related

# Migration & Troubleshooting — Developers **Audience:** Engineers migrating present → `memorix-record/2` and debugging runtime failures.

• How to read this guide
• The central mental model
• 1. Present → memorix-record/2
• 2. `associated*` rejection (what V2 forbids)
• 3. Validation error categories (quick)
• 4. Failure matrix (runtime HTTP)
• 5. Isolation & acceptance orgs
• 6. Ops narrative migration drill (WI-100)
• 7. Rollback and repair strategies
• 8. Embedding migration in host tooling
• 9. Decision tree
• 10. Anti-patterns

# Getting Started & Tutorials — Developers **Audience:** Engineers taking Memorix from zero to the core loop: metadata → data → Memory/pipeline → relationships.

• 1. Installation for agents
• 2. Getting started
• 3. Best practice — three sides and authoring order
• 4. Tutorial — run the local stack
• 5. Tutorial — first read and write
• 6. Tutorial — metadata and abstracts
• 7. Tutorial — memory to pipeline
• 8. Tutorial — relationships
• 9. Where to go next

# Connector Framework — Developers **Audience:** Engineers authoring provider connectors with `@x12i/memorix-connector-sdk`.

• How to read this guide
• The central mental model
• 1. Packages and install
• 2. Protocol and defineConnector
• 3. Streams, workflow, collectStream
• 4. Credentials and Credorix
• 5. Host surfaces
• 6. Reference connectors
• 7. APS certification
• 8. Must and must-not
• 9. Related