# Locia — guiding-thread project management for AI agents

> Locia is a project-management discipline for work executed by an AI agent. It
> treats the core problem not as coordinating labour (human PM) but as allocating
> a forgetful executor's ATTENTION over a lossless store of meaning, governed from
> the outside. A living funnel with one apex and one lit thread: ★ Star (one goal)
> → ⟋ Course (one active project/epic) → ▼ Focus (one task, WIP=1).

This is an open standard of the kova ecosystem (Apache 2.0). Locia's primary
consumer is an AI agent, so the standard is published in agent-consumable form.

## The problem it solves

An AI agent systematically "does the easy thing, not what was asked" and
"selectively forgets instructions." Not laziness — two mechanical causes:

- Context falls out of the window. Long sessions get summarized; specific rules
  survive worse than the general gist. The agent remembers WHAT it is doing but
  forgets HOW it was asked.
- Attention decays inside the window. Even a loaded rule loses the fight for
  attention against the concrete task — exactly when the agent is most focused.

The fix is structure, not exhortation: externalize continuity and boundaries into
a re-read artifact, and re-project the relevant rules into the local focus.

## The standard

- [Locia specification](https://locia.kovanex.dev/): the full standard, RFC-style.
- [Full specification, plain text](https://locia.kovanex.dev/llms-full.txt): the entire spec inlined for single-fetch ingestion.

## The shape (funnel + one lit thread)

- ★ Star — the one enduring goal; changes very rarely and only by explicit decision.
- ⟋ Course — exactly one active project/epic; others are PARKED, not deleted.
- ▼ Focus — exactly one task at the tip; WIP=1.
- One-thread rule (anti-drift): the thread ★→⟋→▼ is always traceable both ways.
  Anything not on the thread is drift, and it is VISIBLE.

## The control loop (life of a thread)

FLOOD (ground: gather rich context from the store) -> FOCUS/LIGHT (emit ONE task =
scope subgraph + bound invariants + DoD; re-project invariants into the window;
WIP=1) -> WORK (execute at the tip, re-reading the thread artifact to survive
amnesia) -> BOUNDARY/SIGNAL (any target outside the scope subgraph must be
signalled, never silently absorbed) -> CLOSE (an independent, adversarial verify
checks the DoD; write a return point to the store) -> NEXT.

## Related

- Kovanex (the platform Locia runs on): https://kovanex.dev/
- UFN (the token-economical wire format Locia slices are emitted in): https://ufn.kovanex.dev/