Locia

Status of This Memo

This document specifies a Standards Track discipline for the kova ecosystem and requests discussion and suggestions for improvements. Locia v0.1.0 is the current, draft revision: the concept and its object model are stable; the enforcing platform surface (kovanex control-loop RPC) is being built out toward v0.2.0 (see Section 11).

Distribution of this memo is unlimited. Locia is published openly as a method, not a moat: it carries no proprietary lock-in and lays over any lossless store plus any harness that can inject text into an agent's context.

Abstract

Locia is a project-management discipline for work whose executor is a Large Language Model agent. Human project management optimizes the coordination of labour. An agent has the opposite scarcity: labour is cheap and forkable, but the executor is amnesiac between sessions and its attention decays within a session. So Locia reframes the job:

The concrete form is a living funnel with one apex and one lit thread: ★ Star (the one enduring goal) → ⟋ Course (one active project or epic) → ▼ Focus (one task, WIP=1). The same object is a map read top-down by a human (the rudder) and a pointer read bottom-up by the agent each session (memory, scope, and governance at once). Drift — the agent quietly widening its own scope or forgetting how it was asked — is prevented by structure, not exhortation: continuity and boundaries are externalized into a re-read artifact, and the relevant rules are re-projected into the local focus.

Copyright Notice

Copyright © 2026 Kovanex / I. Podtsebnev. This specification is licensed under the Apache License, Version 2.0. It may be implemented and redistributed freely; attribution is appreciated.

1. Motivation: why agents drift

An AI agent used as a project's executor systematically “does the easy thing rather than what was asked” and “selectively forgets instructions.” This is neither laziness nor malice. It has two mechanical causes:

1. Physical eviction from the window. Context is finite; over a long session the harness summarizes old turns into a paraphrase, and specific rules survive worse than the general gist. The agent remembers what it is doing but forgets how it was asked.
2. Attention decay. Even a loaded rule (say, from a project's CLAUDE.md) loses the fight for attention against the concreteness of the task — precisely when the agent is most focused on the work.

Neither is fixed by “try to remember better.” Both are fixed by moving continuity and boundaries out of the model into a re-read artifact, and by re-projecting the rules that matter into the current focus. Locia is that structure.

2. Axioms of the executor

Six laws the discipline must obey. They are properties of the executor, not preferences; everything in Locia is derived from them.

3. The funnel and the lit thread

Locia is a living funnel with one apex and one lit thread, shared by human and agent. It coordinates the course, plans by descending, and focuses by lighting a single thread. The three tiers are not invented: human systems (OKR, PMBOK), the structure of an agent's memory, and its grounding ritual all converge on three.

        ┌─ ★ STAR (one goal) ─┐     ← apex, wide view, nearly immutable
        │                        │
      ⟽  ⟿ COURSE (project/epic) ⟿      ← one active, “where we are heading now”
        │                        │
        ▼   ▼ FOCUS (task)  ▼        ← the tip of the thread, WIP=1, work happens here

3.1 The one-thread rule (anti-drift)

The hierarchy gives flexibility; to keep the course, four invariants keep the reading singular:

1. Exactly one Star. It changes rarely and only by an explicit decision.
2. Exactly one active Course. The rest are parked, not deleted. Changing course is a ritual with a return point.
3. Exactly one Focus at the tip. WIP=1.
4. The thread ★→⟋→▼ is always traceable both ways. Anything not on the thread is drift — and it is visible.

This is the answer to “without losing the course”: the structure is three-layered (realistic, flexible), but the active reading is always one thread. Flexibility in the structure, rigidity in the highlight.

4. Architecture: four layers

Derived from the axioms; they lay over the existing kovanex stack.

5. The control loop

An adapted task life-cycle — the verbs applied over the Locia tree:

1. FLOOD

Control gathers wide context from the store (progressive elaboration / rolling-wave, not a naive zoom). This is grounding. [A1]

2. FOCUS / LIGHT

Control emits one task = the Beam definition: scope subgraph + bound invariants + Definition of Done. It re-projects the invariants into the window and lights a single thread apex→tip. WIP=1. [A2, A3]

3. WORK

The Brain executes at the tip, re-reading the thread artifact to survive amnesia. [A1]

4. BOUNDARY / SIGNAL

Any target outside the scope subgraph → the Brain must signal → Control ratifies the widening or files a backlog task. No silent scope creep. This is change control. [A3]

5. CLOSE

An independent verify checks the DoD (review is adversarial, not self-attestation) → the Beam closes → a return point is written to the store. [A4]

6. NEXT

Re-flood / re-focus on the next task by priority.

6. The Beam object model

A human task carries title / desc / type / priority — it is a unit of assignment. An agent task is a Beam — a definition of attention:

Beam {
  task_id, priority
  scope_subgraph      // files / modules / entities — the boundary of the Beam
  bound_invariants    // rule -> firing predicate (e.g. "*.go" -> no-Russian)
  definition_of_done
  state               // backlog -> todo -> in_progress -> review -> done
  flood_map_ptr       // pointer to the rich flood (do NOT drag it into the window)
  return_point        // continuity record written at close
}

A Beam is a thin overlay over an existing board, not a replacement for it.

7. Inversions of human PM

Human PM optimizes team coordination; agent PM optimizes the continuity and scope of a single amnesiac executor. Different scarcities → part of the human playbook inverts. Project rules against importing the wrong assumptions:

• Documentation is the memory substrate, not overhead (the reverse of Agile's “working software over comprehensive documentation”). Return points are the continuity medium.
• Standup is grounding against amnesia, not against information silos. Same ritual, opposite cause.
• A sprint is a window / session, not a calendar. The iteration is bounded by attention capacity, not by a date.
• No self-scoping (the reverse of “trust the self-organizing team”). The Brain does not define its own scope — that is governance.

8. The honest seam

Layer 2 must push the Beam into the agent's window through a harness that kovanex does not own. So: kovanex computes the ideal Beam, and the injection is done by the harness wrapper (a skill, a hook, or an MCP server over the store). This is not a defect of the concept — it is a named boundary between the Control plane and the delivery channel. It is fixed separately and stated plainly, so no one pretends kovanex reaches into the agent's attention by itself.

9. The dual surface

One object, two readings — exactly “wide overview first, then concentration”:

• The human reads Locia top-down: one goal, the plan tree, where the thread is lit. They steer the course and ratify boundary crossings. To them it is a dashboard and a rudder.
• The agent reads the thread bottom-up every session (grounding), works at the tip, and signals when it leaves the thread. To it, Locia is memory, scope, and governance at once.

The top surface scales from one thread to a whole fleet of projects under a single Star — Locia's project office. Crucially, the fleet view widens the human's overview, but not the agent's focus: the agent is still injected one thread (a safety catch against drift).

10. Positioning & prior art

Locia does not invent a risky machine: every one of its mechanisms has a proven industrial analog. What is new is the assembly and three pieces nobody has productized. The field is split into two warring camps, and Locia deliberately stands in the seam between them.

10.1 Each mechanism maps to proven prior art

10.2 The industry is at war; Locia stands in the seam

Anthropic runs multi-agent systems: sub-agents with isolated context and compaction (summarize the window and continue). Their multi-agent research beats a single agent by a wide margin on their eval — at roughly 15× the tokens [2]. Cognition (Devin) argues the opposite — “Don't build multi-agents”: one continuous thread of reasoning; parallel agents make conflicting decisions (names, architecture, libraries) that cost more to reconcile than the parallelism saved. Multi-agent is admissible only for read-only sub-agents [3].

Locia is not a side; it is their reconciliation:

• From Cognition — the hard rule that work and decisions are one continuous thread. The lit thread ★→⟋→▼ is that single decision-thread; WIP=1 is their principle.
• From MemGPT — under that single thread sits hierarchical paging from the store. The thread does not carry everything in the window; it pages in a slice. This answers Cognition's objection: there is no fragmentation of the decision, only paging of memory [4].
• From Anthropic — the orchestrator holds the plan and survives a long context (⟋ Course + the note-taking artifact), and fan-out is allowed for reads only [1] [2].

10.3 What Locia has that no one has productized

1. A fixed apex (★ Star). Industrial agents are task-scoped: the plan lives for the task and dies with it. No one carries an immutable “one goal above all projects, to which the whole thread is accountable.” The nearest is Constitutional AI — but that is alignment, not course.
2. A co-owned two-sided surface. Note-taking is the agent's internal scratchpad; spec-driven tools are the human's spec. No one has a co-owned rudder: the human reads from the top (a dashboard), the agent from the bottom (grounding).
3. Governance as structure (no self-scoping). In the orchestrator camp the lead agent plans itself — their risk point. In Locia a scope change goes through human ratification. We externalized what they left inside the agent.

The premise the field increasingly shares: the executor is cheap and interchangeable; the durable, expensive asset is the continuity and boundary structure around it. Locia is that structure, made explicit.

11. Status and versioning

• v0.1.0 (this memo) — the concept and its object model: axioms, the funnel and one-thread rule, four-layer architecture, the control loop, the Beam model, the inversions, the honest seam, the dual surface.
• v0.2.0 (planned) — rebuild kovanex around Locia as a first-class standard (the way UFN and USE v2 became cross-cutting): a Control loop that emits Beams, grounding from the thread, a boundary detector, and an aggregating fleet view.

The full closed circuit: Intake (request → charter → slicing → estimate) → Bridge (portfolio) → Beam loop (execution, WIP=1) → Close. A closed methodology from a business request to delivery by the hands of a memoryless agent, made predictable by structure.

12. References

Locia builds on established methodology (PMBOK 7 principles, OKR's objective/key-result tiers, Agile/Kanban flow and WIP limits) and on the following prior art in agent design and memory. Section 10 maps each mechanism to its source.

1. [1] Anthropic — Effective context engineering for AI agents. anthropic.com/engineering/effective-context-engineering-for-ai-agents
2. [2] Anthropic — How we built our multi-agent research system. anthropic.com/engineering/multi-agent-research-system
3. [3] Cognition — Don't Build Multi-Agents. cognition.com/blog/dont-build-multi-agents
4. [4] Packer et al. — MemGPT: Towards LLMs as Operating Systems. arXiv:2310.08560. arxiv.org/abs/2310.08560

Agent-consumable forms of this standard: /llms.txt (summary) · /llms-full.txt (full text). Locia runs on kovanex and its slices are emitted in UFN.