EPIC: Bootstrap a0-symbolics symbolic control plane #1

Open
opened 2026-08-22 22:29:55 +00:00 by lost-rob0t · 0 comments
lost-rob0t commented 2026-08-22 22:29:55 +00:00 (Migrated from github.com)

Objective

Turn this fork into a0-symbolics, but bootstrap it in the correct order:

  1. Phase 0 — debloat Agent Zero context using Agent Zero itself. No Prolog-RLM dependency.
  2. Measure the lean baseline and prove task quality is preserved.
  3. Phase 1 — introduce Prolog-RLM as the symbolic control plane only after the baseline is understood.

Do not start by replacing the agent loop or wiring RLM everywhere.

Bootstrap sequence

Phase 0: Agent Zero context debloat only

Goal: make the existing Agent Zero loop dramatically leaner without changing its fundamental architecture.

Work in this order:

  • remove/reduce eager tool prompt loading
  • reduce promptinclude depth/count/token budgets
  • tighten memory recall/result limits and avoid ambient unrelated recall
  • keep large raw tool results out of long-lived prompt history where current extension points allow
  • reduce duplicated/redundant system prompt material
  • keep simple requests simple; complex-task instructions should not inflate every turn
  • add token telemetry so every reduction is measurable
  • build baseline evals before introducing symbolic control

No Prolog-RLM code is required for Phase 0. If a debloat improvement can be done cleanly with existing Agent Zero plugins/hooks/config, do that first.

Phase 1: RLM integration

Only after Phase 0 has a measured lean baseline:

  • add a thin Python bridge to pinned Prolog-RLM
  • use rlm_context_budget first
  • then gated rlm_prompt_compiler
  • then artifacts/state/subagents as separately verified slices

RAGE execution contract

RAGE = Review -> Analyze -> Generate -> Execute, repeated by development workers until the active acceptance gate is satisfied or a real external blocker exists. This is a backlog/work-loop discipline, not permanent Agent Zero prompt text. Runtime RAGE behavior belongs in the optional _rage plugin tracked by #5.

Every worker handling this epic or a child epic must:

  1. Review current main, applicable AGENTS.md, open/merged PRs relevant to the slice, and exact runtime behavior before changing code.
  2. Analyze the smallest falsifiable slice, identify invariants, failure modes, rollback path, and tests.
  3. Generate the minimal implementation and tests.
  4. Execute targeted verification, inspect failures, repair, and loop again. Never treat partial output, timeout, skipped tests, or plausible behavior as success.
  5. Continue to the next useful backlog item when the current slice is complete; do as much useful work as possible rather than stopping after one trivial change.

Loop breakers

  • Same failing tool/signature twice without new evidence -> re-plan or isolate in a fresh worker.
  • Repeated identical error -> retire the approach until new evidence appears.
  • New user correction/instruction supersedes the current plan immediately.
  • No unbounded recursive subagents.

Phase 0 gates

  • Baseline bootstrap/system context token count is reproducible.
  • Tool prompt payload is substantially reduced without breaking task completion.
  • Promptinclude is bounded and cannot silently flood root context.
  • Memory recall is narrower and project-scoped.
  • Large transient tool output is prevented from becoming long-lived context where feasible with current hooks.
  • Generic solving prompt is materially smaller and contains no RAGE runtime procedure.
  • Per-call context/token telemetry exists.
  • Baseline vs debloated eval shows materially fewer tokens with no material task-success regression.

Phase 1 gates

  • Prolog-RLM is pinned to an exact revision.
  • First RLM production path is rlm_context_budget behind a narrow bridge.
  • rlm_prompt_compiler remains gated until exact-path conformance tests pass.
  • Symbolic decisions are explainable and measurable against the Phase 0 baseline.

Current child epic map

  • #2 — Phase-0 context debloat baseline.
  • #3 — tool/skill/prompt context debloat.
  • #4 — persistent Prolog KB memory, evidence, and typed state.
  • #5 — optional RAGE orchestration plugin.
  • #6 — persistent self-modifying core and rollback.
  • #7 — context-quality evals and telemetry.
  • #8 — single-plugin Prolog-RLM control-plane convergence, 500-token starting projection, provider compatibility boundary.
  • #23 — whole-product Symbolics WebUI rebuild with plugin compatibility.
  • #49 — first-class Android shell around the authoritative WebUI.
  • #58 — live Docker end-to-end CI and OpenRouter/provider compatibility.
  • #59 — opt-in full-fidelity local I/O capture and debugging observability.

The active production-convergence work should land through these epics instead of growing one unreviewable mega-issue or mega-PR.

Non-goals for Phase 0

  • No Prolog-RLM integration.
  • No whole-loop rewrite.
  • No symbolic memory rewrite.
  • No unrestricted self-modification.
  • No baked-in RAGE system prompt.

Definition of done

Phase 0 is complete when plain Agent Zero in this fork runs with a materially smaller, bounded, measurable provider-visible context while preserving task quality. Only then does RLM work begin.

## Objective Turn this fork into **a0-symbolics**, but bootstrap it in the correct order: 1. **Phase 0 — debloat Agent Zero context using Agent Zero itself. No Prolog-RLM dependency.** 2. Measure the lean baseline and prove task quality is preserved. 3. **Phase 1 — introduce Prolog-RLM as the symbolic control plane** only after the baseline is understood. Do **not** start by replacing the agent loop or wiring RLM everywhere. ## Bootstrap sequence ### Phase 0: Agent Zero context debloat only Goal: make the existing Agent Zero loop dramatically leaner without changing its fundamental architecture. Work in this order: - remove/reduce eager tool prompt loading - reduce promptinclude depth/count/token budgets - tighten memory recall/result limits and avoid ambient unrelated recall - keep large raw tool results out of long-lived prompt history where current extension points allow - reduce duplicated/redundant system prompt material - keep simple requests simple; complex-task instructions should not inflate every turn - add token telemetry so every reduction is measurable - build baseline evals before introducing symbolic control No Prolog-RLM code is required for Phase 0. If a debloat improvement can be done cleanly with existing Agent Zero plugins/hooks/config, do that first. ### Phase 1: RLM integration Only after Phase 0 has a measured lean baseline: - add a thin Python bridge to pinned Prolog-RLM - use `rlm_context_budget` first - then gated `rlm_prompt_compiler` - then artifacts/state/subagents as separately verified slices ## RAGE execution contract RAGE = **Review -> Analyze -> Generate -> Execute**, repeated by development workers until the active acceptance gate is satisfied or a real external blocker exists. This is a backlog/work-loop discipline, **not permanent Agent Zero prompt text**. Runtime RAGE behavior belongs in the optional `_rage` plugin tracked by #5. Every worker handling this epic or a child epic must: 1. **Review** current main, applicable `AGENTS.md`, open/merged PRs relevant to the slice, and exact runtime behavior before changing code. 2. **Analyze** the smallest falsifiable slice, identify invariants, failure modes, rollback path, and tests. 3. **Generate** the minimal implementation and tests. 4. **Execute** targeted verification, inspect failures, repair, and loop again. Never treat partial output, timeout, skipped tests, or plausible behavior as success. 5. Continue to the next useful backlog item when the current slice is complete; do as much useful work as possible rather than stopping after one trivial change. ### Loop breakers - Same failing tool/signature twice without new evidence -> re-plan or isolate in a fresh worker. - Repeated identical error -> retire the approach until new evidence appears. - New user correction/instruction supersedes the current plan immediately. - No unbounded recursive subagents. ## Phase 0 gates - [ ] Baseline bootstrap/system context token count is reproducible. - [ ] Tool prompt payload is substantially reduced without breaking task completion. - [ ] Promptinclude is bounded and cannot silently flood root context. - [ ] Memory recall is narrower and project-scoped. - [ ] Large transient tool output is prevented from becoming long-lived context where feasible with current hooks. - [ ] Generic solving prompt is materially smaller and contains no RAGE runtime procedure. - [ ] Per-call context/token telemetry exists. - [ ] Baseline vs debloated eval shows materially fewer tokens with no material task-success regression. ## Phase 1 gates - [ ] Prolog-RLM is pinned to an exact revision. - [ ] First RLM production path is `rlm_context_budget` behind a narrow bridge. - [ ] `rlm_prompt_compiler` remains gated until exact-path conformance tests pass. - [ ] Symbolic decisions are explainable and measurable against the Phase 0 baseline. ## Current child epic map - #2 — Phase-0 context debloat baseline. - #3 — tool/skill/prompt context debloat. - #4 — persistent Prolog KB memory, evidence, and typed state. - #5 — optional RAGE orchestration plugin. - #6 — persistent self-modifying core and rollback. - #7 — context-quality evals and telemetry. - #8 — single-plugin Prolog-RLM control-plane convergence, 500-token starting projection, provider compatibility boundary. - #23 — whole-product Symbolics WebUI rebuild with plugin compatibility. - #49 — first-class Android shell around the authoritative WebUI. - #58 — live Docker end-to-end CI and OpenRouter/provider compatibility. - #59 — opt-in full-fidelity local I/O capture and debugging observability. The active production-convergence work should land through these epics instead of growing one unreviewable mega-issue or mega-PR. ## Non-goals for Phase 0 - No Prolog-RLM integration. - No whole-loop rewrite. - No symbolic memory rewrite. - No unrestricted self-modification. - No baked-in RAGE system prompt. ## Definition of done Phase 0 is complete when plain Agent Zero in this fork runs with a materially smaller, bounded, measurable provider-visible context while preserving task quality. **Only then does RLM work begin.**
Sign in to join this conversation.
No milestone
No project
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set.

Reference
nsaspy/a0-symbolics#1
No description provided.