On this page

Atoms · 28 kinds

The unit of knowledge. Every atom declares id, version, body fields specific to its kind, and a list of typed edges. The 28 kinds are organised into 5 layers; pick what fits your domain and ignore the rest.

Anatomy of an atom

An atom is a .prime source file. Every atom has the same shape:

<kind> <PascalCaseName> {
  id: "@scope/kind-kebab-name"
  version: "1.0.0"
  description: "One sentence — appears in summary projection."
  domain: <domain>

  // kind-specific body fields
  // ...

  // edges out (any subset of 14 verbs)
  related:        [@scope/...]
  requires:       [@scope/...]
  validates-with: [@scope/...]
}

Required for every kind: id, version, description, domain. Each kind adds its own required fields (e.g. rule requires claim; method requires steps).

The 5 layers

Layer	Kinds	Role
Data	`fact` `term` `value` `category` `example` `counter-example` `source` `metric`	What is. Verifiable claims, definitions, samples, citations.
Behaviour	`step` `check` `transform` `tool` `method`	What to do. Procedures, validations, transformations.
Composition	`rule` `taxonomy` `pattern` `anti-pattern` `type` `constraint`	What goes with what. Constraints, classifications, recurring shapes.
Meta	`collection` `scope` `tradeoff` `principle` `feedback`	About the corpus. Bundles, scope declarations, design tensions.
Voice & style (domain-flavoured)	`persona` `voice` `template` `provocation`	How to express. Used to varying degrees across corpora — observed in the wild: creative-writing ~10 kinds, security ~12, frontend-design 22 (current upper bound).

Full kind reference

Kind	One-line	Required fields
`fact`	A verifiable claim with confidence.	`statement`, `confidence`
`term`	A definition of a vocabulary unit.	`definition`
`value`	A specific concrete value (constant).	`value`, `unit?`
`category`	A classification slot in a taxonomy.	`category`, `parent?`
`example`	A worked instance of a rule or pattern.	`shows`, `illustrates?`
`counter-example`	An instance that fails a rule or pattern.	`fails`, `why`
`source`	Citation or reference to authoritative material.	`title`, `url?` or `doi?`
`metric`	A measurable quantity (e.g., contrast ratio ≥ 4.5:1).	`name`, `threshold?`
`step`	One step in a procedure.	`action`
`check`	A verification gate (yes / no / details).	`check`
`transform`	An input → output procedure.	`input`, `output`
`tool`	An executable utility used by methods.	`signature`
`method`	A multi-step procedure with inputs, outputs, and contract.	`steps`, `contract?`
`rule`	A constraint with severity and applies-to.	`claim`, `severity`
`taxonomy`	A classification scheme.	`axis`, `buckets`
`pattern`	A reusable solution to a recurring problem.	`problem`, `solution`
`anti-pattern`	A common mistake and why it fails.	`shape`, `fails-because`
`type`	A schema for an object the protocol traffics in.	`fields`
`constraint`	A hard limit or invariant.	`limit`, `applies-to`
`collection`	A curated bundle of atoms.	`members`
`scope`	A focused subset of the corpus.	`focus`, `members`
`tradeoff`	A decision where two values are in tension.	`tension`
`principle`	A higher-level belief that justifies rules.	`statement`
`feedback`	Retrospective observation about prior decisions.	`observation`
`persona`	A named bundle of style for a coherent voice / posture (design lineage, writing style, brand system, …).	`posture`
`voice`	A writing voice (cadence, register).	`register`
`template`	A reusable scaffold for output.	`template`
`provocation`	A creative prompt to push the agent.	`prompt`

Two complete examples

1. A `rule`

rule SqlInjectionPrevention {
  id: "@security/rule-sql-injection-prevention"
  version: "1.0.0"
  description: "Always use parameterised queries — never concatenate strings."
  domain: security

  claim:    "Use parameterised queries; never concatenate user input."
  applies-to: [api-endpoint, data-pipeline]
  severity: critical

  validates-with: [
    @security/source-owasp-input-validation,
    @security/check-sqlmap-scan,
  ]

  contradicts: [
    @security/anti-pattern-string-concat-query,
  ]
}

2. A `method`

method MakeTea {
  id: "@hello-world/method-make-tea"
  version: "1.0.0"
  description: "Boil water, steep tea, optional milk and sugar."
  domain: cooking

  steps: [
    @hello-world/step-boil-water,
    @hello-world/step-steep-tea,
    @hello-world/step-add-milk,
  ]

  contract: {
    must-include: [
      @hello-world/fact-water-boils-at-100c,
      @hello-world/term-steep,
    ]
    must-avoid: [
      @hello-world/anti-pattern-microwave-tea,
    ]
  }

  enhances: [
    @hello-world/voice-british-tea-time,
  ]
}

Picking kinds

A small corpus uses 5–8 kinds. As datapoints from real corpora: a creative-writing Prime might use ~10 kinds (heavy on Voice & Style); a security Prime ~12 (heavy on Data + Composition + Behaviour); the frontend-design Prime 22 (the current upper bound). The kinds you don't use simply don't appear in your corpus.

Need a kind we don't have? See Custom kinds — adding a kind to the protocol is a 4-file patch and a Tier-2 RFC.