Research-Stack/6-Documentation/famm/POSSIBLE_CONSTRAINED_AGENT_APPROACHES.md

# Possible Constrained-Agent Approaches

## Purpose

Consolidate the project's prior SmallCode-like approaches and add GLIA as a persistent-memory substrate.

This document is intentionally named **possible approaches**. It is a routing map, not a final architecture claim. Each approach is a candidate route for shrinking the active computational field while preserving receipts, memory, verification, and Warden boundaries.

```text
small/local model or constrained agent
→ memory recall
→ context-budget projection
→ TODO/plan decomposition
→ patch/logogram mutation
→ verifier/governor check
→ adversarial dual tests
→ FAMM scar/coarsening or promotion
→ memory update receipt
```

## External anchors

### SmallCode

```text
Repository: https://github.com/Doorman11991/smallcode
Role: constrained local coding agent / execution field shrinker
```

SmallCode is a terminal-native coding agent optimized for small local LLMs, especially 7B-20B models. It uses budget-managed context, TODO-file decomposition, patch-first editing, forgiving tool parsing, working memory, verifier/governor logic, early-stop detection, and optional escalation.

### GLIA

```text
Repository: https://github.com/Eshaan-Nair/Glia-AI
Role: local-first cross-tool persistent memory / recall substrate
```

GLIA describes itself as a local-first memory layer that captures AI conversations, builds a searchable knowledge graph, and injects relevant context into new prompts. It has two shared-memory interfaces: a browser extension for chat websites and an MCP server for coding tools. Both read/write the same backend memory store.

GLIA features especially relevant to this stack:

```text
browser extension + MCP server
shared local memory store
hybrid retrieval: sentence vectors + chunk vectors + FTS5
knowledge graph extraction
HyDE retrieval
small-to-big retrieval
surgical sentence trimming
background indexing
project isolation
prune_memory for outdated facts
SQLite/WAL local mode
```

## Consolidated approach map

| Approach | Role | Existing project analogue | External analogue |
|---|---|---|---|
| Hermes field-operator bridge | controlled workflow operator | Hermes / Warden receipts | GLIA MCP + SmallCode skills |
| FastPatchCheck | fast viability check | local patch smoke test | SmallCode verifier |
| StructuralAdmissibilityCheck | invariant legitimacy check | Judge structural gate | SmallCode governor |
| BridgeModel_GlobalGate | hard execution choke point | guarded transition | SmallCode tool routing / GLIA injection guard |
| BridgeModel_Linter | architecture safety scanner | Warden pre-runtime alert | SmallCode parser repair / GLIA sanitization |
| GCL Combined Coding Surface | typed coding substrate | encode/mutate/repair/gate/receipt | coding tools + MCP surfaces |
| Logogram Chirality Route Gate | semantic kernel routing | glyph/code kernel phase | BoneScript / semantic code packets |
| TraceInvariant direction | session continuity / drift prevention | trace budget + failure ledger | GLIA memory + SmallCode TODO/session state |
| Anti-FAMM | witness blind-spot adversary | projection-nullspace attack | memory/summary hidden-failure tests |
| Anti-BraidStorm | hostile crossing adversary | false survivor detection | multi-agent patch convergence tests |

## Approach A — Memory-first agent substrate

Use GLIA as the memory substrate.

```text
conversation / coding session
→ store_memory / Save Chat
→ embeddings + knowledge graph triples
→ recall_context / auto-injection
→ project-scoped memory packet
```

Project mapping:

```math
\Gamma_{\mathrm{GliaMemory}}
=
(
X_{\mathrm{history}},
\pi_{\mathrm{chunk}},
W_{\mathrm{recall}},
R_{\mathrm{inject}},
I_{\mathrm{decision}},
G_{\mathrm{project}},
K,
\epsilon
)
```

| Packet term | Meaning |
|---|---|
| `X_history` | full conversation / project history |
| `pi_chunk` | chunking, embedding, graph extraction |
| `W_recall` | retrieved context / graph facts |
| `R_inject` | prompt or MCP context injection |
| `I_decision` | remembered project decisions and constraints |
| `G_project` | project/session isolation guard |
| `K` | retrieval, storage, and prompt budget cost |
| `epsilon` | stale, irrelevant, or missing memory residual |

Warden checks:

```text
stale memory
wrong project memory
cross-project leakage
prompt injection in retrieved chunks
PII leakage
over-injection / context noise
memory facts treated as proof
```

## Approach B — Execution-first constrained coding agent

Use SmallCode-like architecture as the execution substrate.

```text
raw coding request
→ budgeted context summary
→ TODO decomposition
→ patch-first edit
→ compile/lint/test verifier
→ Warden decision
→ escalation only on hard fail
```

Project mapping:

```math
\Gamma_{\mathrm{SmallCode}}
=
(
X_{\mathrm{task}},
\pi_{\mathrm{summary}},
W_{\mathrm{todo}},
R_{\mathrm{patch}},
I_{\mathrm{compile}},
G_{\mathrm{local}},
K,
\epsilon
)
```

Useful when:

```text
local models are weaker than frontier models
context is limited
whole-file rewrites are risky
patches can be locally verified
session state must survive across turns
```

Warden checks:

```text
patch compiles but violates global invariant
summary hid relevant code path
tool parser repaired into wrong command
TODO plan says done while tests fail
local loop / repetition detected
unbounded cloud escalation
```

## Approach C — GLIA + SmallCode combined route

This is the strongest practical integration.

```text
GLIA recalls durable project memory
→ SmallCode executes constrained patch plan
→ verifier emits receipt
→ GLIA stores final decision and scars
```

Pipeline:

```text
1. identify_active_project / project selection
2. recall_context for relevant prior decisions
3. SmallCode builds TODO plan
4. execute patch-first edit
5. run verifier / tests / lint
6. Anti-FAMM checks summary/memory blind spots
7. Anti-BraidStorm checks false convergence across candidate patches
8. store_memory with final decision, failure, or scar
9. NUVMAP Delta-DAG records the route
```

This route turns memory and execution into a closed loop:

```text
memory informs action
action emits receipt
receipt updates memory
future recall sees the scar or promotion
```

## Approach D — Hermes-style authority bridge

Hermes remains the authority/workflow bridge.

```text
tool or agent may execute/suggest/schedule
but may not promote without receipts
```

Use Hermes when the route needs explicit permissioning:

```text
skill execution
scheduled audit
automation
cross-tool workflow
write authority
promotion-state changes
```

Project mapping:

```text
Hermes = authority substrate
GLIA = memory substrate
SmallCode = execution substrate
FAMM = scar/residual substrate
BJW = decision substrate
NUVMAP = route-memory substrate
```

## Approach E — FastPatch + StructuralAdmissibility route

This is the local-to-global verifier route.

```text
FastPatchCheck
→ local viability
→ StructuralAdmissibilityCheck
→ invariant legitimacy
→ escalationNeeded or promotion
```

Use it as the default verification stack for coding agents:

```text
patch is syntactically valid
patch compiles/tests locally
patch preserves architectural invariant
patch has no hidden route leak
patch emits receipt
```

## Approach F — Logogram/code-kernel route

Use semantic/logogram kernels to reduce active tool calls.

```text
many low-level tool calls
→ one high-level semantic kernel
→ deterministic expansion
→ compile/check receipt
```

External analogue:

```text
BoneScript in SmallCode
```

Project analogue:

```text
LOGOGRAM_RADIX_FIELD
GCCL_COMPLEX_PHASE_CODEC
CODE_LOGOGRAM_KERNEL
```

Rule:

```text
internal bases may be weird;
external recovery must be boring.
```

So every code-logogram must expand back to ordinary files, tests, bytes, or standard source code with receipts.

## Approach G — GCCL complex phase action routing

Use GCCL complex phase routing to classify agent actions:

```text
phase  1   → survivor action / apply patch
phase  i   → witness action / inspect, recall, summarize
phase -1   → cancellation action / revert, remove, undo
phase -i   → adversarial action / probe, fuzz, Warden test
```

With omnidirectional GCCL:

```math
\theta=e^{i\phi}
```

becomes a continuous routing field rather than a four-state switch.

Use this when actions need to carry:

```text
chirality
witness direction
cancellation pressure
scar burden
receipt confidence
adversarial pressure
```

## Approach H — Adversarial duals as mandatory hardening

Before promotion, run:

```text
Anti-FAMM
→ searches for invisible residuals and false scars

Anti-BraidStorm
→ searches for false convergence, aliasing, wrong-handed recombination, receipt drift
```

For memory-agent systems, this becomes:

```text
Anti-FAMM memory test:
  Does retrieved context omit a fact that changes the decision?

Anti-BraidStorm patch test:
  Do several agents converge on the same wrong edit because they share a poisoned memory or false summary?
```

## Approach I — NUVMAP Delta-DAG execution receipts

Every memory/action/check route becomes a Delta-DAG edge:

```text
state_t
→ recalled context
→ patch proposal
→ verifier result
→ adversarial result
→ state_t+1
```

Receipt packet:

```text
memory_hash
context_hash
patch_hash
test_hash
scar_hash
promotion_state
```

This gives the project replay, provenance, and failure reuse.

## Recommended practical architecture

```text
GLIA persistent memory
→ SmallCode constrained execution
→ FastPatchCheck / StructuralAdmissibilityCheck
→ Anti-FAMM / Anti-BraidStorm adversarial probes
→ FAMM scar/coarsening ledger
→ NUVMAP Delta-DAG route receipt
→ GLIA store_memory / project summary update
```

Short form:

```text
GLIA remembers.
SmallCode acts.
FAMM scars.
BJW decides.
NUVMAP receipts.
Hermes governs.
```

## Possible implementation tiers

### Tier 0 — Manual doctrine

Use the document as workflow guidance only.

```text
recall manually
patch manually
verify manually
store decision manually
```

### Tier 1 — Local memory + constrained execution

Use GLIA for memory and SmallCode for coding.

```text
GLIA recall_context
→ SmallCode plan/patch
→ tests
→ GLIA store_memory
```

### Tier 2 — Receipt-bearing workflow

Add FAMM-style receipts.

```text
memory hash
patch hash
test hash
scar class
promotion decision
```

### Tier 3 — Adversarial hardening

Add Anti-FAMM and Anti-BraidStorm.

```text
memory blind-spot probes
summary-loss checks
false-convergence checks
patch alias checks
```

### Tier 4 — GCCL phase-routed agents

Use complex phase routing to classify actions and automate Warden behavior.

```text
apply / witness / cancel / adversarial probe
```

## Warden boundaries

Allowed claim:

```text
These approaches give the project several concrete routes for constrained local-agent execution, persistent memory, patch-first coding, logogram-code kernels, and adversarial verification.
```

Disallowed claim:

```text
SmallCode, GLIA, or any local-agent stack guarantees correctness without tests, receipts, project isolation, and Warden checks.
```

Hard rules:

```text
memory is evidence, not proof
summaries are lossy
retrieval can be stale
patches must be verified
agent convergence can be false
cloud escalation must be bounded
project isolation must be checked
receipts dominate model confidence
```

## Project sentence

The possible constrained-agent approach is to pair GLIA-style durable memory with SmallCode-style constrained execution: recall the right project context, decompose into atomic TODOs, mutate by patch/logogram kernels, verify through fast and structural gates, attack with Anti-FAMM and Anti-BraidStorm, then store the resulting receipt, scar, or promotion back into the memory graph for the next run.

## Citations

```bibtex
@online{doorman11991_smallcode,
  title        = {SmallCode},
  author       = {{Doorman11991}},
  organization = {GitHub},
  url          = {https://github.com/Doorman11991/smallcode},
  urldate      = {2026-05-18},
  note         = {Terminal-native coding agent optimized for small local LLMs; README branch master.}
}

@online{nair_glia_ai,
  title        = {GLIA — Persistent Memory for AI Coding Tools},
  author       = {Nair, Eshaan},
  organization = {GitHub},
  url          = {https://github.com/Eshaan-Nair/Glia-AI},
  urldate      = {2026-05-18},
  note         = {Local-first memory layer with browser extension and MCP server sharing one memory store.}
}
```