Agent infrastructure
Why Liminate matters for AI agents.
An agent that cannot show its state is an agent you have to trust on faith. Liminate is a small readable language an agent can write its state in, so you can check it.
Agent reliability is bottlenecked on inspectability. Liminate provides a bounded, executable prose substrate that the four skills use to make state, intent, attention, and continuity legible at runtime.
The four pressures
State drift
Models forget what was verified, what was guessed, and what the user already corrected. Session contracts write those down in a sentence the next turn can read.
liminate-session-contracts persists verified claims, inferred claims, locked decisions, open questions, and active corrections as Liminate-readable state with runtime-checked citations.
Intent ambiguity
A request can mean several things. The prompt compiler picks one shape before the answer is written, so the response aims at the real ask.
prosecode-prompt-compiler emits a seven-verb Intent IR — explain, create, transform, analyze, decide, plan, fix — with slots, missing fields, and contradictions surfaced before generation.
Context overload
Long conversations bury what matters. The context pager scores each block and writes down whether to keep it, page it, or drop it.
prosecode-context-pager applies a deterministic keyword-plus-recency score against the active intent and records retain / page / evict decisions — no embeddings, no network.
Continuity loss
Handing a session to another agent usually flattens it into a vague summary. The handoff packet keeps the verified, the inferred, the open, and the corrected separate.
prosecode-handoff-packet exports a Markdown transfer object with fourteen required sections, preserving the epistemic boundary between what is known, what is guessed, and what is still unresolved.
The shared move
Each skill takes something an agent normally keeps invisible — what it believes, what it is trying to do, what it is paying attention to, what it would tell the next agent — and writes it down in a sentence you can read.
Each skill externalises a layer that is usually implicit in model weights or hidden state — belief, intent, attention, continuity — into bounded Liminate sentences. The trust boundary moves from "trust the model" to "read the program."
Why a language, not a schema
A schema is a shape. A language has verbs. The agent does not just fill in blanks; it writes a small program that says what it did and why, in words the reader already knows.
Liminate's verbs (claim, cite, verify, decide, filter, combine, …) give the agent a constrained but expressive surface. The interpreter enforces constraints (e.g. cite as a runtime substring check) so the recorded state is not merely structured — it is checked.
This is the same thesis the rest of the site argues, applied one layer up: bounded readable language as a trust surface.