Details

The fourfold deficiency

Current agent frameworks answer almost entirely within the confines of the conversation. You ask in one paragraph, it answers in one paragraph — this looks like collaboration, but is essentially an infinite extension of question-and-answer. A true assistant should perceive what is known, what is unknown, and what is unknown-unknown.

1. Constructiveness — Answers remain at the level of reaction to a single conversation, lacking the ability to build toward a goal step by step. It does not construct; it merely responds.
2. Continuity — Every conversation starts almost from zero. Once the rhythm is broken, follow-up work on complex projects basically collapses. Humans re-align through communication; AI seems unable to.
3. Verifiability — Output sounds reasonable but does not hold up under scrutiny. Even a basic task like checking a paper struggles to guarantee accuracy, let alone converting unknown-unknowns into known-unknowns in complex design.
4. Weight judgment — AI cannot distinguish importance. Some tasks are on the critical path, some are nice-to-have, some are noise. The framework offers no cognitive tool for this — so the agent grasps at everything.

State desync

In real collaboration, the states of human and AI are almost always out of sync. The user knows their context, the weight of their intentions, and the trade-offs behind every decision; the AI knows none of it. In human teams, misalignment is repaired by talking it out; in AI collaboration, one interruption is enough to invalidate the rest of the project. This is not a prompt-engineering problem — it is a structural defect at the framework level.

The 1% foundation

We are not building a 100% shell. There are already too many all-capable frameworks that do nothing deeply. WAM builds only the bottom 1% of the foundation — and builds it solidly. The foundation is not a feature list; it is a fundamental answer to how an agent collaborates with a human: how state is synchronized, how goals are constructed, how progress continues, how uncertainty is managed.

The sage and the doer

The architectural vision: a deepest sage with the hands of a pragmatic doer. The sage sees the whole situation, traverses all possibilities, knows when to be fast and when to be slow, senses the boundary between what we know and what we don't, and is sensitive to weight. The doer takes only verifiable steps, pushes when feasible and admits when not, focuses on the most important 1% and leaves continuable progress — never an empty promise. Whether one agent or many run beneath, the user faces a single, unified, constructive collaboration entity.

Six response principles

• Slow down to speed up. Establish the state first, then take the next step.
• No bluffing. Acknowledge real difficulty, then work through it together.
• A directional 1%. Every step moves toward the goal, however small.
• Weight-sensitive. Hold the critical path; ignore the noise.
• Pragmatic and honest. Push when feasible, admit when not. Honesty beats perfection.
• Stay in sync. Alignment is the framework's core duty.

“Wait a Minute” is a reminder, a posture, a design philosophy — a comment written before every line of code. When the model tends to quickly generate a plausible-looking output, WAM says: wait. Do we really understand the situation? If not, don't rush to answer. Go figure it out first.

The state model — four files

All collaboration state lives under workspace/, versioned as Markdown + git — both human and AI can read and write directly; every step can be diffed and rolled back.

Hard rules

1. Read state.md and goals.md at the start of every session; write log.md at the end — even one line.
2. Every “done” must carry evidence: artifact path, command output, test result. No evidence = not done.
3. Every goal carries one of three weight tiers: critical path / enhancement / noise. Noise is not elaborated, not scheduled.
4. Unknown-unknowns must be explicitly listed, never feigned knowledge.

The collaboration protocol — six steps

1. Read — Load the situation, the goals and weights, and the tail of the progress log.
2. Wait — Wait a Minute: is the goal clear? Is the situation understood? Should this step really be taken?
3. Judge — What is the highest-weight step right now? Critical path first; never do noise.
4. Do — Take exactly one verifiable step.
5. Verify — Provide evidence; if infeasible, say so honestly.
6. Write — Update state / goals / log / decisions.

Development governance

To keep the project from drifting off course, unverified work lives in directions/ until it passes the promotion gate.

Promotion requires ALL of: a decision recorded in workspace/decisions.md (reason, alternatives, weight judgment); evidence cited (artifact path / command output / test result); the artifact relocated; the direction folder archived to directions/archive/. A failed direction is archived the same way — with the failure recorded.

01 — Ecosystem survey

• No framework offers human-readable, human-editable, cross-session shared state. Memory is kv checkpoints (LangGraph), prompt files (CLAUDE.md), or model self-written notes (Letta).
• No weight judgment: only CrewAI infers importance at save time; no critical-path/enhancement/noise tiers anywhere.
• Verification is an industry-wide gap — Anthropic's own docs admit unverified “done” is an illusion.
• Planning artifacts are one-shot (CrewAI replans per round; Aider architect) — no living goal object with progress.

02 — Memory & state architectures

• Layering is consensus: CoALA's four memory classes (working/episodic/semantic/procedural) map naturally onto state/goals/log/decisions.
• Reflection and compression paths are validated (Generative Agents' reflection; MemGPT's memory-pressure paging).
• Known failure modes: memory drift, hallucinated memory, retrieval misses, staleness — no unified invalidation mechanism.
• Human-shared state is unresearched: all memory systems are agent-internal. This is WAM's blank space.

03 — Unknown-unknowns & weight judgment

• Smithson's ignorance quadrant (known / known-unknown / unknown-unknown) is exactly the vocabulary state.md's three sections already use.
• Confidence can be cross-checked across three channels: token probability, semantic entropy (Kuhn 2023), verbalized confidence (Lin 2022; Tian 2023). Verbalized confidence is systematically overconfident (ADVICE).
• CPM (critical path method) in LLM agent planning has no dedicated literature — WAM's clearest original contribution.
• Open problem: unsupervised detection of unknown-unknowns is essentially unsolved — the explicit registry + human-in-the-loop is the honest answer.

Goals — M1 (critical path)

• [x] Targeted survey: ecosystem / memory & state / unknown & weight
• [x] Establish directions/ folders + promotion gate
• [x] Open 4 competing directions: global-route / substrate / agent-plugin / weight-first
• [x] Public site (this site)
• [ ] Design conversation: who it's for / first demo / v1 boundaries
• [ ] Each direction produces a proposal + minimal falsification experiment (vertical slice)
• [ ] Convergence: first verified vertical slice defines M1 architecture

Decisions made so far

1. The foundation comes first as a state model and protocol — not by initializing a code project.
2. State is stored as Markdown + git, not a database / JSON / YAML.
3. State directory named workspace/, not wam/ or .wam/.
4. Development governance: directions/ folders + promotion gate (evidence / proposals / decisions).
5. Four competing directions opened; convergence rule: first verified vertical slice wins.
6. Public site as a bilingual atompunk presentation artifact.

Progress log (recent)

• 2026-08-06 — Project founded; M0 foundation delivered (state model + six-step protocol); all files translated to English.
• 2026-08-07 — Targeted survey (3 parallel research tasks); governance established; 4 directions opened; site built, v2 (constructivism), v3 (age layer) and deployed.

Nothing here is final. The ideas may be revised, extended, or overturned as the architecture progresses — that openness is part of WAM itself.