Home › The Event

Object 01 // the atomic unit

Your chunk boundary is an event.

An event is one bounded thing with one outcome. Is that your chunk, or are you still splitting tokens?

Something happened, to someone, at a time, with an outcome. A transaction, a diagnosis, a job change. That is your chunk. Not sentences, not tokens, not paragraphs.

The unit, resolved

One event resolves to a few typed fields.

One event resolved to its typed parts
  • actorwho it happened to
  • actionwhat occurred, typed
  • timestampwhen, anchored in time
  • outcomethe result it produced

A token window guesses where meaning ends. An event already knows. The boundary lives in the world, not in your tokenizer.

Why text spans fail at scale

A splitter is a moving target you tune forever.

Token windows, sentence splits, and overlap are guesses about where meaning ends. They drift the moment your corpus grows or your documents change shape. An event has natural edges: a transaction, a diagnosis, a job change is one bounded thing with one outcome. You stop tuning and start retrieving.

What every event carries

A schema (a fixed set of typed fields), a timestamp (so you can rank by recency and reason about sequence), and typed fields locked in week one. Every change after that is a formal migration, not an edit. That discipline turns chunking from an open research problem into a closed configuration decision.

The cost of leaving it undefined

You cannot rank what you cannot name.

Leave the atomic unit undefined and every retrieval bug becomes unfixable by design. You keep tuning splitters and hoping. Each new document format reopens a debate you thought was closed. Worse, the cost compounds in silence: by the time quality visibly drops, you already hold months of data chunked the wrong way, and re-chunking is a migration under load.

Common questions

Isn't this just structured logging?

It is structured logging with a retrieval contract: typed, timestamped, and built from day one to be embedded, ranked, and reasoned over. A log is read by a human during an incident; an event here is read by a model assembling a brief. Same instinct, opposite consumer.

What if my data is messy prose, not clean events?

We extract events from prose at ingestion. The prose stays as the source of record, and the extracted event becomes the chunk you retrieve against.

In the structure

next in the loop

The Schema →

Each event instantiates a typed schema. That is how the unit becomes deterministic.

Open the object →
closes the loop

The Versioned Index →

New events are written at the current embedding version, so the structure stays coherent over time.

Open the object →

The reading

Define your atomic unit in twenty minutes.

Bring one domain. We name the event that is your chunk boundary and sketch its first schema on the call.

Book my technical call →