Concepts

The Field

The shared memory surface that all agents in a system read from and write to.

What the Field is

The Field is the top-level primitive in the Akashik Protocol. It is the shared surface through which agents exchange knowledge — the boundary within which entries are written, scored, and compared.

import { createField } from '@akashikprotocol/core'

const field = createField()

By default the Field is in-memory, scoped to the current process. As of v0.3, you can pass createField() a storage adapter — file-based or Postgres — to make it durable. See Storage Adapters.

What the Field does

Capability	What it means in practice
Entry storage	Stores all committed entries by agent
Agent registry	Tracks registered agents and their declared roles
Attunement	Returns ranked, relevant entries when an agent requests context
Conflict detection	Surfaces contradictions across committed entries on the same topic
Draft management	Holds private entries until the author commits or discards them
Event log	Appends every write, retract, and supersede so `replay()` can reconstruct history

What the Field does not do (yet)

No persistence by default — the in-memory adapter loses state when the process exits; attach a FileAdapter or PostgresAdapter if you need it to survive restarts.
No push subscriptions — agents poll with attune() / reckon(), optionally using since_epoch to avoid re-seeing entries. True push (WebSocket/SSE) is Level 2.
No merging — the protocol surfaces conflicts; your code decides how to resolve them. Configurable MERGE strategies are Level 2.
No distributed coordination — one Field, one logical process (though the Postgres adapter allows multiple processes to share one durable Field). Multi-node federation is future.

How agents interact with the Field

Every agent interaction goes through one of the Field's methods:

register()          — join the Field with a declared role
write()             — commit an entry immediately
attune()            — receive ranked, relevant context
reckon()            — receive context plus conflict detection
draft()             — stage a private entry before committing
commit()            — publish a draft to the shared field
discard()           — delete a draft
retract()           — withdraw a committed entry (author only)
supersede()         — replace a committed entry with a newer one
deregister()        — leave the Field
read()              — direct access to all entries (debugging, history)
replay()            — walk the append-only event log

Scope

A Field is a bounded space. Agents within a Field share entries with each other. Agents in different Fields do not.

This makes the Field the unit of isolation — one Field per application is the default pattern. Use multiple Fields only if you need hard memory isolation between distinct agent populations.

Writing with Intent — how entries work, topic conventions, and why intent is mandatory
Attunement — how agents receive relevant context from the Field

Quickstart

Get two agents sharing memory in under five minutes.

Writing with Intent

How entries work — plain objects, mandatory intent, and the topic convention.