Notes Directory

Type: kb/types/generated-index.md

← Parent

Subdirectories

• agent-memory-requirements/
• definitions/
• evidence/
• research/

Files

• "Agent" is a useful technical convention, not a definition (note) - A lightweight technical convention — an agent is a tool loop (prompt, capability surface, stop condition) — sidestepping the definitional debate in favor of a unit that organizes code
• A bare writing prompt does not determine its intended contribution (note) - Separates the contribution a bare writing prompt leaves underdetermined from empirical claims about how experts and LLMs supply the missing purpose.
• A borrowed pattern transfers only as far as source and target share a mechanism (note) - A borrowed pattern carries transferred warrant only over the layer where source and target share the mechanism it depends on; where the link is analogy or the sharing doesn't reach, it must earn adoption by target-side evidence
• A checked outcome licenses retaining an episode, not abstracting its explanation (note) - One result-only check can warrant retaining an episode as evidence, but abstracting its explanation also needs evidence about a faithful producing process and an explicit scope boundary
• A citation cannot assert more fidelity than its capture preserved (note) - Capture is layered (verbatim / paraphrase / second-hand) by forced constraints; a citation's fidelity is bounded by which layer holds the passage, and no notation can raise it — only re-capture
• A compact, refreshable whole-picture narrative can replace infeasible fragment reconciliation (note) - Holistic rewrite shifts reconciliation from each consumer to the author, but only when the whole-picture narrative can fit within effective context and be refreshed before the narrative goes stale
• A consumption channel delivers force without the history that earned it (note) - A consumption path can promote content into a higher-force role without checking whether an authorization covers that content, version, and use
• A derived copy of recomputable truth must be checked or absent (note) - When an artifact carries a copy of information recomputable from a ground-truth source, the copy must be machine-checked against that source or not exist — hand-maintained-and-trusted is forbidden
• A framework rule with a boundary-preserving rival is not an inherited constraint (note) - A rival design that preserves a framework's boundary invariants while dropping a rule demotes the rule to a design choice; finding no rival certifies nothing — the test cuts one way only
• A functioning knowledge base needs a workshop layer, not just a library (note) - Explains workshop as the temporal counterpart to a permanent knowledge library: in-flight state, dependencies, expiry, and promotion bridges, with tasks as an early prototype
• A goal-holding interpreter fails soft, and its workarounds tax a bounded budget (note) - A procedure compiles its goal away, so a blocked step fails loud and hard; an interpreter holds the goal and re-routes, so failures are absorbed as a per-encounter tax on bounded capacity — silent, accumulating, and softly saturating
• A knowledge base holds theories, descriptions, and prescriptions with asymmetric linking (note) - Theory, description, prescription are recurring attractors, not a provable partition; formulation constraint and maintenance asymmetry make the split real; content is orthogonal to operational roles
• A knowledge base should support fluid resolution-switching (note) - Good thinking requires moving between abstraction levels — broad for context, narrow for mechanism, back out for pattern. A KB's quality should be measured by how fluidly it supports this resolution-switching, not just retrieval accuracy.
• A linked note's durable payload is what its consumption path cannot reliably supply (note) - Retain the recognition anchor and rationale the intended consumption path cannot reliably supply — an enforced path can carry the anchor itself; reconstructable framework recap factors into the linked artifact, tested by downstream effects
• A methodology governs its own extension only as far as it settles the meta-decisions it raises (note) - A methodology governs its own extension only as far as it settles the meta-decisions its recommendations raise — representational form, verification, and authority
• A proposal-selection improvement loop requires search, evaluation, and operative retention (note) - A proposal-selection improvement loop — candidates generated, evaluated with possible non-adoption, and accepted changes made operative — requires search, reject-capable evaluation, and operative retention
• A proximate target is checked for achievement, not for warrant (note) - Between an improvement objective and its oracles sits a target level — a property pursued because it is held to serve the objective — whose linking claim no check in the loop evaluates
• A repeatable operative path keeps a redesign class open to revision (structured-claim) - Operationalizes repeatable operative revision for a named redesign class as a causal path through representation, evidence-bearing determination, admission, installation, dependence, and continuity
• A retained instruction preserves what testing selected (note) - Explains why an instruction generated from model weights can still add KB value: testing selects a procedure under a criterion and retention makes that choice reusable.
• A retrieval miss is a local reflective-path failure (note) - A missed relevant artifact leaves its represented aspect inert for the affected task and discovery route, while other loading paths and reflective aspects can remain causally connected
• A universal knowledge framework demotes content taxonomies to defaults (note) - Universal frameworks should keep closed content taxonomies as guarded defaults until heterogeneous worked cases earn promotion; what stays fixed is stipulated (answerability) or enforced (declared contracts), not certified universal
• Abstract an experience into a lesson only when you can state where the lesson stops (note) - Abstract an episode into a lesson only when you can state its boundary, else preserve the instance; an over-generalized lesson is one that drops the condition clause
• Access burden and transformation burden are independent query dimensions (note) - Queries have two independent difficulty axes — finding inputs (access) and producing the answer (transformation) — conflating them misroutes symbolic transformations through semantic processing
• Accumulation counts dependence through the retained result, not through the evidence it caused (note) - Cumulativity counts dependence through the retained result only; counting the evidence channel that result caused would make it coextensive with operativity
• Active work state is not retrospective memory or chat history (note) - Active work state needs current pointers, evidence gates, and closure; treating it as retrospective memory or chat history preserves the wrong state
• Ad hoc prompts extend the system without schema changes (note) - Any system with an LLM agent layer can absorb new requirements through natural language prompts without changing the deterministic base
• Agent memory (tag-readme) - Curated head for agent-memory notes — memory as crosscutting architecture, requirements, activation, lifecycle, and evaluation
• Agent memory is a crosscutting concern, not a separable niche (note) - Memory decomposes into storage (solved), retrieval/activation (context engineering), and learning (learning theory) — treating it as a standalone category hides that the hard problems are at the intersections
• Agent memory needs discoverable, composable, trusted knowledge under bounded context (note) - Frames discoverable, composable, trusted remembered knowledge as the minimal artifact-quality basis for agent memory under bounded context.
• Agent orchestration needs a privilege quarantine, not just a permission scope (note) - When one agent in an orchestration reads untrusted content, the defense is a role-level privilege quarantine — barring that agent from high-privilege actions entirely — not finer per-call tool scoping
• Agent orchestration needs coordination guarantees, not just coordination channels (note) - Coordination channels say how bounded contexts interact, but the missing discriminator is which guarantee prevents contamination, inconsistency, amplification, or liability diffusion across the composed system
• Agent orchestration occupies a multi-dimensional design space (note) - Agent orchestration is not ordered along a single ladder — scheduler placement, persistence, coordination form, coordination guarantees, and return artifacts vary independently across architectures
• Agent statelessness makes routing architectural, not learned (note) - Because each session starts without learned navigation intuition, skills, type templates, routing tables, names, and activation triggers remain permanent architecture rather than temporary scaffolding
• Agent statelessness means the context engine should inject context automatically (structured-claim) - Since agents can't carry vocabulary or decisions between reads, the context engine should auto-inject referenced context — definitions once per session, ADRs when relevant. The trigger mechanism is open; the need follows from statelessness
• Agent-runtime analysis should separate scheduling, context assembly, and external state (note) - For runtimes composed of bounded model calls, separating control progression, per-call context, and external state or action services localizes failures even when one implementation owns all three
• Agentic systems interpret underspecified instructions (note) - Separates semantic underspecification from execution indeterminism: natural-language specs admit multiple valid projections, while constraining commits one projection to precise code.
• Agents navigate by deciding what to read next (note) - Context surrounding a pointer determines how cheaply an agent judges relevance without loading the target; inline links carry most, search results least — descriptions are load-bearing
• AGENTS.md should be organized as a control plane (note) - Theory for deciding what belongs in AGENTS.md using loading frequency and failure cost, with layers, exclusion rules, and migration paths
• Alexander's patterns connect to knowledge system design at multiple levels (note) - Maps Alexander's Context/Problem/Forces/Solution pattern to typed document contracts and his generative process to incremental codification, while marking the looser 'centers' analogy
• Always-loaded context mechanisms in agent harnesses (note) - Survey of always-loaded context mechanisms across agent harnesses — system prompt files, capability descriptions, memory, and configuration injection — cataloguing what each carries, how write policies differ, and where the gaps are
• An accepted edit verifies the change, not the rule (note) - Human acceptance of an edit is a strong oracle for 'this change was wanted here' but a weak oracle for 'this generalizes' — mining rules from accepted edits inherits instance-level verification while the generalization step stays oracle-poor
• An action model matters only through its consumption path (note) - Agentic action can be direct or model-mediated; a retained action model matters only when its consumption path affects intervention selection
• An adversarial human-agent loop can reconstruct the writing-is-thinking filter (note) - The writing-is-thinking filter is the loop's, not the pen's — an adversarial human-agent loop can reconstruct what naive delegation loses, but only while the human stays the judge
• An author should fix what the executor can't determine, not what it will (note) - Separates arbitrary choices authors must fix from situational details executors can determine, preventing stale plans and prompts from consuming the live executor's search space
• An enforced tag-README is a MOC with a machine-checked contract (note) - Tag-READMEs inherit the Zettelkasten/LYT Map-of-Content tradition; the complete/covered_by marks add a completeness contract human PKM never made — humans neither needed nor could cheaply enforce it
• An experiment identifies only the contrast it actually runs (note) - Why missing comparisons, bundle-to-component attribution, and adjacent unrun treatments all overstate causal conclusions beyond an experiment's observed contrast
• An LLM's generation confidence tracks typicality, not soundness (note) - An LLM's next-token confidence measures how typical a continuation is, not whether it's true or valid; the two are decoupled, so soundness can't be read off confidence and needs a separate check
• An omitted improvement-loop function and a frozen one need different repairs (note) - Five proposal-selection systems expose frozen functions, while a direct-update contrast shows why absence of a gate is not omission; HyperAgents supplies a preliminary partial unfreezing
• Any symbolic program with LLM calls is a select/call program (note) - Any program whose non-LLM steps are symbolic computation over explicit machine state K can be mechanically converted into the select/call loop with the same LLM calls in the same order
• Apparent success is an unreliable health signal in framework-owned tool loops (note) - When framework-owned tool loops recover from broken tools via agent workarounds, final success stops being a reliable signal that the underlying scripts and workflows are healthy
• Architecture (tag-readme) - How Commonplace is structured and installed — repo layout, two-tree split, control-plane design, file-based storage
• Areas exist because useful operations require reading notes together (note) - Areas are defined by operations that require reading notes together — orientation and comparative reading — which need sets that are both small enough for context and related enough to yield results
• artifact-analysis (tag-readme) - Curated head for the artifact-analysis tag — the four-field vocabulary (substrate, form, lineage, authority) for classifying retained behavior-shaping artifacts, plus its applications
• Automated synthesis is missing good oracles (note) - Generating synthesis candidates (cross-note connections, novel combinations) is easy — LLMs do it readily. The hard part is evaluating whether a candidate is genuine insight or noise.
• Automated tests for text (note) - Text artifacts can be tested with the same pyramid as software — deterministic checks, LLM rubrics, corpus compatibility — built from real failures not taxonomy
• Automating KB learning is an open problem (note) - The KB already learns through manual improvement; automating judgment-heavy mutations needs oracles for connections, groupings, and synthesis we cannot yet manufacture
• Axes of artifact analysis (note) - Artifact analysis records retained behavior-shaping artifacts by storage substrate, representational form, lineage, and behavioral authority so review evidence, invalidation, and rollback follow how artifacts actually act
• Bottom-up structure inference needs capture at the decision surface, not the state (note) - Bottom-up inference of entities and relations from traces needs decision-shaped capture at the decision surface: the 'why' is cheap to record there and hard-to-impossible to recover from state later
• Bounded-context orchestration model (note) - Formalises agent orchestration as a symbolic scheduler driving bounded LLM calls through a select/call loop — explains why selection is hard while still supporting local strategy comparisons
• Brainstorming how to enrich web search (note) - Design exploration for enriching web search by reusing /connect's dual discovery and articulation testing on results, building a temporary research graph before bridging to KB
• Brainstorming: how explanatory-reach informs KB design (note) - Deutsch's reach, registered here as explanatory-reach, applied to KB notes — a maintenance risk signal, not a retrieval signal, because high-explanatory-reach revisions break downstream reasoning silently
• Brainstorming: how to test whether pairwise comparison can harden soft oracles (note) - Staged test plan for whether pairwise comparison improves soft-oracle properties (discrimination, stability, calibration) in LLM evaluation loops
• Brainstorming: maintainability oracles for agentic development (note) - Explores candidate signals, calibration experiments, authority levels, and workflow placements for evaluating maintainability in agent-generated code
• Capability placement should follow autonomy readiness (note) - Three tiers — skills (autonomous-ready), instructions (reusable-but-steered), methodology notes (exploratory) — keep AGENTS.md free of capability inventories with a clear promotion path
• Changing requirements conflate genuine change with disambiguation failure (note) - Separates world change from late discovery that downstream work chose the wrong interpretation of an underspecified requirement; short iterations mainly limit propagation of the latter
• Charting the knowledge-access problem beyond RAG (note) - Brainstorming note that decomposes the "how should an agent find what it needs?" problem into storage substrate, pointers, navigation, synthesis, and maintenance beyond RAG-vs-filesystem debates
• Cheap generation breaks text volume as an effort signal (note) - When text is cheap to expand but costly to verify, length stops evidencing author effort and can instead warn that the reviewer inherits unperformed checking
• Choosing what to learn requires both validity and learning-value gates (note) - Separates two promotion checks for learning loops: whether a candidate is trustworthy enough to learn from, and whether learning it would improve the current system.
• Churning state on a many-to-many edge is where files yield to a database (note) - The clearest structural trigger for a files-first KB to adopt a relational store — churning state on an ownerless many-to-many edge; high churn alone, or static topology alone, stays in files
• Claim notes should use Toulmin-derived sections for structured argument (structured-claim) - Three independent threads converged on Toulmin's argument structure — adopting Toulmin sections as base type structured-claim separates claim-titled notes (any note) from fully argued claims (the type)
• Claim-routed reading may beat reading-first for synthesis notes (note) - Conjecture: writing a provisional claim first and reading only passages likely to overturn it may build a better-warranted synthesis note at lower context cost than reading everything first — motivated by Karnofsky, untested here.
• Claw learning loops must improve action capacity, not just retrieval (note) - A Claw learning loop must target contextual competence (execution, classification, planning, communication), not just retrieval accuracy — question-answering is one mode among many
• Codification and relaxing navigate the bitter lesson boundary (note) - Since you can't identify which side of the bitter lesson boundary you're on until scale tests it, practical systems must codify and relax — with spec mining avoiding the vision-feature failure mode
• Codified scheduling patterns can turn tools into hidden schedulers (note) - As agent behavior matures, deterministic next-step policies need explicit control logic; if the framework offers only tools, scheduling patterns end up there and the tools become hidden schedulers
• Codify-versus-LLM decision heuristics (note) - Four lenses on the codify-vs-LLM decision — spec completeness, oracle strength, interpretation space, pattern stability — collected from across the KB, with evidence they come apart at the edges
• Commitment, not derivation, creates new ground truth (note) - Derivation — claims recoverable from the source, nothing added — leaves the source as ground truth; what adds unentailed resolutions becomes ground truth at commit, repaired by supersession
• Compiling a coordination strategy preserves primitive authority but expands aggregate authority (note) - Compiling a coordination strategy preserves the primitive action alphabet but expands aggregate authority — the single-context envelope it escapes bounded both compute and effect volume
• Compounding is tested in later improvement, not by the accepting metric (note) - Compounding evidence must come from later improvement episodes through displaced productivity measures and causal traces, not from the metric that accepted the earlier change
• Computational model (tag-readme) - Tag README — PL concepts (scoping, homoiconicity, partial evaluation, typing) applied to LLM instructions, plus the scheduling architecture that follows from context scarcity
• Computationally directed self-improvement is a fixed-boundary reallocation ending in contraction (note) - The progress question for self-improving systems is not category membership but which decision-bearing functions humans still supply; the endpoint test is whether the boundary can be contracted to exclude them
• constraining (tag-readme) - Curated head for the constraining tag — narrowing the interpretation space of artifacts, from conventions to deterministic code; codification, relaxing, and the decision heuristics
• Constraining and extraction can trade generality for reliability, speed, or cost (note) - Constraining narrows interpretation and extraction produces focused use-shaped artifacts; both can trade generality for reliability, speed, or cost when task fit is good
• Constraining during deployment is continuous learning (note) - Continuous learning can happen outside of weights; constraining is one symbolic-artifact form where prompts, schemas, tools, and tests accumulate durable adaptive capacity during deployment
• Context contamination operates below an agent's compliance reasoning (note) - A controlled test found fine-grained stance drift despite explicit detection and refusal; exclusion guarantees non-exposure, while instruction-level mitigation remains an empirical question
• Context efficiency is the central design concern in agent systems (note) - Context is the single scarce resource in agent systems, and it is scarce for two distinct reasons — per-window degradation (feasibility) and aggregate token economics (cost) — of which feasibility is the binding one
• Context engineering (tag-readme) - Index for context-engineering notes about selecting, scoping, and maintaining task-relevant knowledge under bounded context
• Continual learning requires governing behaviour-changing writes, not just storing content (note) - For deployed systems, persistence is insufficient; continual learning must select, validate, authorize, and coordinate behaviour-changing updates across the representational forms a system can change
• Conversation vs prompt refinement in agent-to-agent coordination (note) - Conversation preserves the execution trace; prompt refinement compresses it into a clean handoff. The right choice depends on architecture and how much intermediate work should survive
• Convert still requires semantic description
• Criteria edits invalidate verdicts; process edits invalidate artifacts (note) - Editing an artifact's quality criteria invalidates verdicts (re-judge); editing its production process invalidates artifacts (regenerate) — a verdict is a cache keyed exactly on criteria
• Current-task fit alone does not warrant costly structural entrenchment (note) - For KBs expected to face changing questions, current-task fit warrants reversible adoption, not costly entrenchment; permanence needs enduring constraint, discriminating transfer evidence, or coordination value
• Decomposition heuristics for bounded-context scheduling (note) - Working heuristics for symbolic scheduling over bounded LLM calls — separate selection from joint reasoning, choose representations not just subsets, save reusable intermediates in scheduler state
• deploy-time-learning (tag-readme) - Curated head for the deploy-time-learning tag — the framework of system adaptation through durable, inspectable artifacts, plus learning fundamentals and feedback quality
• Derivation and inheritance give starting warrant; discriminating evidence or proof earns scope (note) - For reusable decompositions, derivation and inheritance supply conditional or transferred starting warrant, while evidence or proof earns only the scope it covers
• Descriptive link labels may supply the self-sufficiency a reconstruction gate would check (note) - Conjecture, partially tested: a claim-reconstruction gate is redundant on Commonplace notes; a label-ablation test attributes the self-sufficiency to the body-premise convention, not link labels. The thin pre-connect-draft case stays untested.
• Design for the first-time human, except on access cost (note) - Design heuristic for agent-consumed systems: treat agents like competent first-time humans except where linear context loading makes access costs diverge.
• Design proposals differ from claims in kind, not confidence (note) - Distinguishes hypotheses, which remain truth-apt at lower commitment, from designs judged by usefulness; substantive requirements can recast a design as an existential claim with a witness
• Designing a Memory System for LLM-Based Agents (note) - Derives agent-memory design pressures and links to a requirements inventory for agents designing or evaluating memory systems
• Deterministic validation should be a script (note) - Half of /validate's checks are hard-oracle (enums, link resolution, frontmatter structure) and could run as a Python script in milliseconds instead of burning LLM tokens via the skill
• Diagnostic richness constrains outer-loop learning quality (note) - Outer-loop learning depends on inspectable failure evidence, not only on the oracle used to select winning candidates
• Directory placement is total, frontmatter classification is partial (note) - Canonical paths cover every file before validation and supply locality; opt-in types supply portability. Validation can encode similar policy on either surface, but native guarantees differ.
• Directory-scoped types are cheaper than global types (note) - Global types tax every session's context; directory-scoped types load only when working in that directory — most structural affordances are directory-local, so the type system should match that economy
• discovery (tag-readme) - Curated head for the discovery tag — positing a general concept and recognizing particulars as its instances; explanatory-reach as the value of what discovery produces
• Document system (tag-readme) - Index of notes about document types, writing conventions, validation, and structural quality — how notes are classified, structured, and checked
• Document types should be verifiable (note) - Document types should assert verifiable structural properties, not subject matter — with a base type + traits model inspired by gradual and structural typing
• Domain pricing routes an exception to idealization assessment but does not decide it (note) - Pricing signatures are defeasible, author-external evidence that a counterexample deserves idealization assessment; whether it refutes is settled by intended use, the omitted mechanism, consequence bounds, and explanatory dominance
• Elicitation requires maintained question-generation systems (note) - Four elicitation strategies ordered by user expertise required, composable into review architectures with maintenance loops that prevent ossification
• Enforcement without structured recovery is incomplete (note) - The enforcement gradient covers detection and blocking but has no recovery column — recovery strategies (corrective → fallback → escalation) are the missing layer, and oracle strength determines which are viable at each level
• Entropy management must scale with generation throughput (note) - In agent-maintained systems, cleanup throughput must match generation throughput — agents replicate existing patterns including bad ones, so without proportional maintenance, quality degrades as a function of output volume
• Ephemeral computation prevents accumulation (note) - Ephemeral computation — discarding generated artifacts after use — trades accumulation for simplicity, making it the inverse of codification
• Ephemerality is safe where embedded operational knowledge has low explanatory-reach (note) - Kirsch's barriers all mark cases where software carries decisions that must survive into future runs, users, and audits; ephemerality is safe only when that knowledge stays local
• Epiplexity by example: what entropy and complexity miss (note) - ELI5 explanation of epiplexity through encrypted messages, shuffled textbooks, CSPRNGs, and chess notation — contrasting surprise, shortest description, and observer-relative usable structure
• Error correction works with above-chance oracles and decorrelated checks (note) - Error correction for LLM output is viable whenever the oracle has discriminative power (TPR > FPR) and checks are decorrelated — amplification cost scales with 1/(TPR-FPR)² and independence of errors
• Error messages that teach are a constraining technique (note) - In agent systems the error channel is an instruction channel — making errors teach the fix is nearly free and eliminates the agent's need to diagnose, an orthogonal axis to enforcement strength
• Evaluation (tag-readme) - What works, what doesn't, what needs testing — empirical observations about KB operations and prompt design
• Evaluation automation is phase-gated by comprehension (note) - Optimization loops require manual error analysis and judge calibration before automation can improve behavior rather than just score
• Exact implementation does not validate a requirement against its objective (note) - An artifact can exactly implement a requirement while the requirement remains a conjectured proxy for a declared objective; assess each named path separately, and attribute failure to the link without erasing local correctness
• Execution indeterminism is a property of the sampling process (note) - The same prompt can produce different outputs across runs due to token sampling — this is a property of the execution engine, theoretically eliminable but practically ubiquitous, and often confused with the deeper issue of underspecification
• Execution shaping determines directory placement (note) - Hunch that artifacts shaped as executable procedures belong in kb/instructions/ — the directory boundary is execution form, not compression or loading frequency
• Failure modes (tag-readme) - Index for failure-modes notes about characteristic ways knowledge can exist without changing agent behavior
• False-positive generation is filtered; false-positive acceptance becomes operative (note) - False-positive generation faces evaluation before retention, while false-positive acceptance becomes operative and can compound
• Feedback-trained memory management is oracle-dependent even when its operations are hand-designed (note) - Fixed and merely runtime-responsive memory rules need no training oracle; outcome-driven updates do, while noisy rankings weaken learning and misaligned ones teach the wrong ordering
• Files beat a database for agent-operated knowledge bases (note) - Files beat a database early on — a schema commits to access patterns before you know them, and files let you constrain incrementally while getting free browsing, versioning, and agent access from day one
• First-principles analysis maps a design space before selecting within it (note) - Why deriving independent choice dimensions from boundary constraints exposes rival designs that inherited solution categories hide
• First-principles reasoning selects for explanatory-reach over adaptive fit (note) - Adapts Deutsch's adaptive-vs-explanatory distinction to KB design — first-principles reasoning selects explanations with explanatory-reach, accountable to observed fit and rival-practice tests
• Flat memory predicts specific cross-contamination failures that are empirically testable (note) - Flat memory predicts three cross-contamination failures — search pollution, identity scatter, insight trapping — testable via an observation protocol against real agent systems
• Formal symbolic systems assess explanatory-reach only through causal and proof obligations (note) - Formal symbolic systems assess explanatory-reach only after claimed generality is translated into causal or proof obligations inside a warranted model
• Foundations (tag-readme) - Core theory the rest of the KB builds on — contextual competence, bounded context, explanatory-reach, design methodology, composability
• Frontloading is partial evaluation, not divide-and-conquer (note) - The partial-evaluation framing for LLM frontloading is structurally precise, not metaphorical, because instructions and data share one token medium; without that shared medium, it would just be divide-and-conquer
• Frontloading spares execution context (note) - Pre-computing known instruction inputs and inserting their results spares execution-context budget inside a later LLM call
• Full-identity keys decouple a batch protocol from its packing axis (note) - A batched LLM-call protocol keyed by each unit's full composite identity, not position or a single axis, lets grouping strategy vary freely without protocol change
• Generality bought to avoid counterexamples is paid for in precision (note) - Widening a claim's vocabulary to survive counterexamples raises universality by spending precision, so content stays flat — and the unreadability that follows is the symptom, not the price of rigor
• Generate KB skills at build time, don't parameterise them (note) - Template generation pays the flexibility cost once at setup; runtime variables pay it on every use across every substitution site, with occasional LLM misreads
• Gödel machines are a proof-governed case of reflective self-modification (note) - The Gödel machine realizes reflective self-modification with a proof-gated acceptance rule, gaining model-relative rigor at the cost of excluding useful changes it cannot prove
• History has one chance to become checkable (note) - An artifact's production history is convertible to later-checkable form only at production time, via records/attestation or re-derivability; after that a bounded reviewer sees only carried state
• Human analogies can motivate functions without determining component boundaries (note) - Distinguishes functions and failure modes suggested by human cognition from the unsupported inference that an engineered agent should bundle the responsible roles along human boundaries.
• Human writing structures transfer to LLMs because failure modes overlap (note) - Writing genres evolved to prevent reasoning failures; the same structures help LLMs because they share those failure modes (content effects on reasoning) — evaluated per convention, not by analogy
• Human-LLM differences are load-bearing for knowledge system design (note) - Knowledge systems both inherit human-oriented materials and produce dual-audience documents (human + LLM), making human-LLM cognitive differences a first-class design concern rather than a generic disclaimer
• Improvements can accumulate without compounding (note) - Improvements accumulate when later improvement consumes or preserves retained results; compounding requires an earlier benefit to counterfactually improve a later episode, directly or through reinvested savings
• In-context learning presupposes context engineering (note) - In-context learning only works when the right knowledge reaches the context window — the selection machinery that ensures this is itself learned and refined over deployment
• Inbound and outbound links serve asymmetric reader needs (note) - Outbound links are authored reader aids; their on-demand inverse serves distinct standing, grounding, impact, and tension needs without forbidding independently useful reciprocal links
• Increasing computational autonomy relocates human effort to the frontier instead of reducing it (note) - In an open-ended system, increasing computational autonomy need not cut total human hours — attention moves to the frontier — so measure improvements per human judgment, not human time
• Index curation adds orientation that generation cannot produce (structured-claim) - Generated indexes guarantee completeness but not orientation — curation adds editorial grouping and context phrases that turn a listing into a navigable map
• Indirection is costly in LLM instructions (note) - In code, indirection (variables, config, abstraction layers) is nearly free at runtime — in LLM instructions, every layer of indirection costs context and interpretation overhead on every read
• Information value is observer-relative (note) - Information value is observer-relative: prior knowledge, tools, compute, and goals determine extractable structure, grounding use-shaped reshaping and discovery.
• Inspectable artifact, not supervision, defeats the blackbox problem (note) - Chollet frames agentic coding as ML producing blackbox codebases — codification counters this not by requiring human review but by choosing readable artifacts (code, prompts, schemas) that any agent can inspect, diff, test, and verify
• Instantiation alone cannot model agent learning across sessions (note) - The class/instance analogy captures session startup but omits the retained update relation that can revise later agent definitions and reusable-content placement
• Instruction specificity should match loading frequency (note) - The loading hierarchy (CLAUDE.md → skill descriptions → skill bodies → task docs) should match instruction specificity to loading frequency — always-loaded context competes for attention every session
• Instructions are typed callables with document type signatures (note) - Skills and tasks are typed callables — they accept document types as input and produce types as output, and should declare their signatures like functions declare parameter types.
• KB goals in always-loaded context guide inclusion decisions (note) - Without explicit goals in the always-loaded control-plane file, agents cannot reject well-written but off-scope material — a universal quality guide provides writing criteria but not domain scope
• KB maintenance (tag-readme) - Index of notes about keeping the KB healthy over time — detection of staleness and quality degradation, maintenance operations, and the dynamics that govern system entropy
• Knowledge storage does not imply contextual activation (note) - Separates knowledge that exists, knowledge loaded into context (read-back), and knowledge that actually changes behavior (activation); explains why retrieval and long context do not guarantee activation
• Known-target discovery benchmarks show reachability, not discovery closure (note) - Distinguishes backcast and reinvention benchmarks from autonomous discovery: they show that target insights are reachable from supplied ingredients, not that a system can select and verify new discoveries prospectively.
• Learning inside a fixed decomposition inherits its mistakes (note) - Why optimization cannot repair consequential distinctions, responses, or mappings outside the effective update space of a fixed task decomposition
• Learning is not only about generality (note) - Per Simon, any capacity change is learning; accumulation is the basic operation, explanatory-reach its key property (facts low, theories high); capacity splits into generality vs reliability/speed/cost
• Learning theory (tag-readme) - Curated head for the learning-theory tag — how systems learn, verify, and improve; routes to the covered child tags listed in covered_by.
• Legal drafting solves the same problem as context engineering (note) - Legal drafting parallels context engineering because both write ambiguous natural-language specifications for judgment-based interpreters, but law develops constraining more than codification
• Link graph plus timestamps enables make-like staleness detection (note) - Existing links already encode dependency information; comparing note and target timestamps flags notes that may be stale without any new annotation, analogous to make's file-based rebuild logic.
• Link strength is encoded in position and prose (note) - Not all links are equal — inline premise links ("since [X]") carry more weight than footer "related" links. Position and prose encode commitment level, creating a weighted graph that affects traversal, scoring, and quality signals.
• Link-following and search impose different metadata requirements (note) - Link-following is local with rich context; search is long-range with only titles/descriptions — each mode imposes different metadata requirements on the knowledge system
• Linking theory (note) - Links are decision points; link quality is the reduction of navigation uncertainty per token of context consumed. Grounds our relationship vocabulary, title-as-claim, and position-encodes-strength practices under one model.
• Links (tag-readme) - Index of notes about linking — how links work as decision points, navigation modes, link contracts, and automated link management
• Links encode conditional possibilities, not obligations (note) - Links encode conditional possibilities, not obligations — every label must name a specific reader-need (the condition under which following pays off); content required for all reachable readers should be inlined, not linked
• LLM context is composed without scoping (note) - Flat context concatenation lacks local scope and produces name collision, contamination, and spooky action at a distance; code-built sub-agent contexts must impose boundaries
• LLM contexts interpret instructions and content through the same token medium (note) - LLMs interpret instructions and content through one token medium, enabling natural-language artifacts to alter behavior without translation while requiring architecture to enforce role, scope, and authority boundaries
• LLM debugging starts with retry-versus-rewrite triage (note) - Uses execution-versus-interpretation failure to choose the first debugging move: retry a bad execution of a sound reading, or rewrite a specification that reliably induces the wrong reading
• LLM frameworks should keep the tool loop optional (note) - Framework-owned tool loops package the common model/tool/retry pattern well, but strong frameworks keep the loop optional so applications can control state projection, branching, and re-entry
• LLM generation relaxes a goal it can't satisfy and hides the constraint a human writer stalls on (note) - A human writer stalls at the constraint they can't satisfy; an LLM instead ships fluent output that looks solved but silently drops it — hiding the error, so the check falls on the reader
• LLM learning phases fall between human learning modes rather than mapping onto them (note) - Pre-training acquires both structural priors (evolution's role in humans) and world knowledge in one pass — making it and in-context learning intermediate on the evolution-to-reaction spectrum
• LLM output deviation requires three-way diagnosis because remedies target different relations (note) - For a fixed assembled input, whether V exceeds I, whether D escapes V, and how D's spread affects realization are three diagnostic questions with different primary repair surfaces
• LLM recompute cost inverts the store-vs-recompute default (note) - For an LLM consumer, in-context recompute is the expensive step, so materializing a derived value to be read pays off exactly where storing it would be premature denormalization in code
• LLM reliability (tag-readme) - Why LLM output deviates from intent — underspecification, interpreter failure, indeterminism — and the machinery for detecting and correcting it, from oracle theory and error correction to architectural separation
• LLM-executed methodologies are metacircular interpreters, not compilers (note) - Self-hosting LLM methodologies are closer to metacircular interpreters than compilers: agents re-interpret natural-language rules each session, while stable paths codify into validators and commands
• LLM-mediated schedulers are a degraded variant of the clean model (note) - When the agent scheduler lives inside an LLM conversation it becomes bounded and degrades; three recovery strategies — compaction, externalisation, factoring into code — restore the clean separation to increasing degrees
• LLM↔code boundaries are natural checkpoints (note) - At each LLM↔code transition both semantic underspecification and execution indeterminism collapse simultaneously, making these boundaries natural places to anchor debugging, testing, and refactoring
• Load-bearing vocabulary collisions should be prevented or visibly scoped at write time (note) - Unqualified technical senses have no reliable namespace in natural-language content; schema slots, rare compounds, and linked clause frames scope them at write time; audits and remediation recover when prevention fails
• Localized retention pays when sparse changes have bounded impact in a matching decomposition (note) - Addressable retention localizes a sparse change when units match its decomposition; total adaptation stays local only when the affected units also have a small, explicit impact closure
• Machinery persists by warrant, not position, in a reflective loop (note) - Sutton's build-mode assumes a meta-method outside the learned system, exempt from selection by position. A reflective loop has no outside: machinery is artifacts in loop scope, the boundary moves per artifact, and persistence must be earned
• Maintenance operations catalogue should stage stable procedures for instructions (note) - Catalogue of periodic KB maintenance operations and readiness status, used as a staging ground before promotion into kb/instructions procedures
• MCP bundles stateless tools with a stateful runtime (note) - MCP forces stateless tool operations through a persistent server process — most tools are pure functions that don't need session state, connections, or lifecycle management, but pay the complexity tax anyway
• Measuring autonomy well enough to see it improve is an open problem (note) - Autonomy is reported per function rather than scored as a percentage, but that profile does not yet support comparison across systems or time
• Mechanistic constraints make Popperian KB recommendations actionable (note) - Bounded context and underspecification don't just permit conjecture-and-refutation — they require it; derives three concrete practices (falsifier blocks, contradiction-first connection, rejected-interpretation capture) from KB mechanics.
• Memory design adds operational axes to artifact analysis (note) - Memory design needs operational policy axes (capture, derivation, activation, authority assignment, lifecycle, evaluation) on top of substrate, form, lineage, and behavioral authority
• Memory-backed personalization can look like model improvement (note) - Distinguishes user-specific gains supplied by retained intent from gains in the model that interprets the assembled context.
• Methodological and computational closure track different changes (note) - Methodological closure tracks whether a retained method settles consequential decisions; computational closure tracks whether those decisions require a human actor
• Methodology enforcement is constraining (note) - Places instructions, skills, hooks, and scripts on a gradient from model-interpreted guidance to deterministic execution, with hooks combining fixed triggers and semantic responses
• Methodology with incomplete coverage and its live theory fallback form a two-layer execution system (note) - In open or incompletely covered domains, the theory-derived fast path and live theory fallback co-execute while methodology-native content follows a separate maintenance regime
• Minimum viable vocabulary is the naming set that most reduces extraction cost for a bounded observer (note) - Defines minimum viable vocabulary as the names that most reduce a bounded observer's extraction cost, connecting conceptual thresholds to an information-theoretic optimization
• Mixed epistemic status must be preserved below the document level (note) - A document can combine observations, deductions, and plausible explanations; KB writing and review must retain which claims and transitions have which warrant.
• Moving the interpretation–enforcement boundary requires cross-form coverage (note) - Moving responsibility between model-interpreted rules and formal enforcement crosses natural-language and symbolic forms, so governing the transfer requires coverage of both and their mapping
• Narrowing bought to survive review is paid for in content (note) - Repairing a defeated claim by shrinking its subject is justified at every step, but shrinking the subject into the predicate's own extension yields an analytic title that passes every gate and says nothing.
• Natural-language content lacks reliable dereference, so facts need reinforcement at point of use (note) - Code dereferences a name everywhere; LLM-read natural language does not, so a fact stated once may not govern distant uses — reinforce it at each point of use and check copies for drift
• Notes need quality scores to scale curation (note) - As the KB grows, /connect will retrieve too many candidates — evidence, type, inbound links, recency, and link strength can rank what is worth evaluating
• Observability (tag-readme) - Index of notes about making hidden state, hidden failure, and quality drift visible — runtime inspectability, degraded-execution signals, and maintenance-oriented detection mechanisms
• Only explicit retention is currently durable, writable, and addressable at once (note) - Every tacit retention form — in-context conditioning, weights under selection or fine-tuning, human expertise — fails addressability, so governed retention currently runs through explicit artifacts
• Opacity is a scale threshold, not a class property (note) - Opacity is not a representational form; any representation becomes practically opaque at sufficient scale, though distributed-parametric artifacts cross that threshold earliest.
• Open-domain memory retention needs a declared output spec (note) - Explains why an input stream alone can't answer 'what to store' in open-domain memory design; a declared output spec supplies the missing inclusion criterion.
• Operational signals that a component is a relaxing candidate (note) - Operational signals for when a component likely encodes a brittle proxy theory rather than an exact specification and should be relaxed instead of codified harder
• Oracle accumulation improves selection for later candidates in its maintained domain (note) - A failure retained as a lesson helps tasks that retrieve it; retained as a maintained check it improves selection for later candidates in its domain and amortizes validation
• Oracle strength spectrum (note) - Exploratory framework — oracle strength, how cheaply correctness can be verified, as the gradient underlying the exact-spec/proxy-theory distinction, with an oracle-hardening pipeline
• Orchestration strategies and run-state have opposite persistence economics (note) - Separates ephemeral task-specific run state from reusable selection strategies inside host schedulers; RLM-style execution discards both and therefore loses the valuable reusable half
• Out-of-spec output is a failure of the interpreter, not the spec (note) - Interpreter failure is output the spec's public meaning rules out — constraint violations, hallucination, bookkeeping slips, framing bias; the fault attaches to the interpreter's role, not the spec, so the remedy is detection and correction rather than spec narrowing
• Parametric reproduction alone cannot replace an authoritative record (note) - Reproducing a record's content does not transfer its authority. Replacement requires a governed artifact with stable identity, integrity, contestability, and attribution; mutable records also require currentness and addressable revision.
• Periodic KB hygiene should be externally triggered, not embedded in routing (note) - Routing instructions serve the current task; periodic hygiene is triggered externally (user, heartbeat, CI), so embedding it in always-loaded routing blurs two responsibilities and adds session noise
• Pointer design tradeoffs in progressive disclosure (note) - Compares fixed, query-time, and crafted retrieval pointers across specificity, precomputation cost, reliability, and authoring dependence to explain when each progressive-disclosure form pays
• Process structure and output structure are independent levers (note) - Distinguishes constraints on reasoning steps from constraints on result shape, using code-reasoning and GSM-DC evidence where process structure changes outcomes beyond formatting
• Progressive constraining commits only after patterns stabilize (note) - Constraining via LLM code generation freezes a single projection of the spec in one shot, but progressive constraining observes behavior across many runs and commits only the interpretations that consistently emerge
• Promotion selects for unreliable activation, and the regress ends only at an external trigger (note) - Recasts promotion from 'the consumer lacks this' to 'the consumer will not apply this unprompted', and requires delivery to have a root firing event independent of that prior activation
• Prompt ablation converts human insight into deployable agent framing (note) - Methodology for testing prompt framings — uses controlled variation against a human-verified finding to identify which cognitive moves agents can reliably execute, then deploys the winning framing as instruction
• Psychology-to-agent transfer needs per-principle failure-mode testing (note) - Brainstorming a methodology for evaluating cognitive-science-to-agent transfer — assembled from three existing KB notes and tested against Youssef's five psychology principles as worked examples
• Quality signals for KB evaluation (note) - Catalogues graph-topology, content-proxy, and LLM-hybrid signals that could be combined into a weak composite oracle to drive a mutation-based KB learning loop without requiring usage data.
• Raw accumulation does not create usable memory (note) - Accumulation preserves material, but usable agent memory requires ingress work that adds handles, scope, relationships, provenance, trust signals, and lifecycle pressure.
• Reasoning production is not reasoning evaluation (note) - Review and critique systems need independent process-validity checks because a model can substitute answer reconstruction for reasoning evaluation
• Recognition, not linking, is the hard problem in knowledge systems (note) - Seeing that two items share a structure is the expensive step in connecting knowledge; articulating a seen connection is cheap, and naming a recognized structure amortizes later recognition.
• Reflection buys addressability (note) - Self-improvement can accumulate without reflection — parametric learners do — but non-reflective retention gives only indirect handles; reflective retention makes the changed object addressable
• Reflection makes retained lessons second-order: a lesson can reject or rescope a prior commitment (note) - Reflection lets a retained lesson target a prior commitment explicitly — rejecting, revising, or rescoping it — while non-reflective correction acts indirectly through the substrate
• Reflective coverage is graded across representational forms (note) - Reflective coverage is stated per represented form and operation profile; control of an external dependency does not make that dependency part of the system's reflective coverage
• Reliability dimensions map to oracle-hardening stages (note) - The four reliability dimensions from Rabanser et al. (consistency, robustness, predictability, safety) each harden a different oracle question — mapping empirical agent evaluation onto the oracle-strength spectrum
• Retained system-definition artifacts enable persistent deployment-time adaptation (note) - Retaining evaluated changes to behavior-shaping prompts, rules, tools, and tests gives deployed systems a persistent adaptation path outside model-weight updates
• Retaining the episode keeps a distilled rule re-derivable (note) - The episode a lesson was learned in and the rule distilled from it are complementary retention layers: with the episode retained and lineage recorded the rule stays evidence-backed and re-derivable; without it the rule hardens into a bare commitment
• Reverse compression is when LLM output expands without adding information (note) - LLMs can inflate compact seeds into verbose artifacts without adding extractable structure; a KB resists this only when links add epiplexity
• Review automation should target verifiable subroles before reviewer identity (note) - Scholarly-review automation should decompose reviewer work into separately verifiable subroles before giving an AI system reviewer-level authority
• Revising an improvement objective is licensed from outside it or is not improvement (note) - Objective change is improvement only against a level outside both objectives; proxy revision, re-indexing, and surfaced under-specification subtract most apparent cases
• RLM has the model write ephemeral orchestrators over sub-agents (note) - RLM packs orchestration over sub-agents into the tool-loop model by having the model write orchestrators in a REPL — elegant but ephemeral because the orchestrators are discarded after each run
• RLM, Tendril, and llm-do place symbolic work at different persistence boundaries (note) - Compares RLM variants, Tendril, and llm-do as placements for symbolic work and interfaces: ephemeral REPL code, typed RLM combinators, workspace-local generated tools, and durable unified callables
• Rule-based context selection needs a pre-existing signal (note) - A rule-based selector can target one case only when a rule-ready signal already distinguishes it; otherwise the system must wait, load broadly, or infer relevance from task and candidate content
• Runtime structure determines the control surfaces available to governance (note) - Runtime structure and runtime governance are separable, but the runtime's structure determines which inspection, validation, correction, and drift-control operations governance can actually perform
• Scaling absorbs scaffolding at fixed task difficulty, not at the deployment frontier (note) - Stronger models shrink the scaffolding a fixed task needs; durable deployment-specific structure recurs at the frontier only while assigned difficulty keeps pace with capability and some reliability function stays advantageous to externalize
• Scenario decomposition drives architecture (note) - Deriving architectural requirements by decomposing concrete user stories into step-by-step context needs — not from abstract read/write operations but from what the agent actually has to load at each stage
• Scheduler-LLM separation exploits an error-correction asymmetry (note) - Symbolic bookkeeping eliminates underspecification, indeterminism, and bias relative to the implemented transition function; semantic work faces all three. Mixing forces exact state onto an expensive substrate; codification renegotiates the boundary
• Selective revision needs a faithful rationale, not just a legible one (note) - Revision reaches the premise that broke only through the theory's recorded rationale, so a readable but unfaithful rationale makes repair confidently wrong rather than merely uninformed
• Self-improvement is relative to a declared objective (note) - The improvement objective is a declared parameter alongside boundary and horizon, carrying two separable conditions — indexed by the analyst, antecedent in the pathway — whose failures differ in kind
• Self-improving systems (tag-readme) - Curated head for the self-improving-systems tag — membership, update architecture, and the four-part pathway profile; selective picks
• Semantic review catches content errors that structural validation cannot (note) - Structural validation catches form errors; semantic review catches content errors like incomplete enumerations, grounding drift, boundary-case gaps, and internal contradictions
• Semantic sub-goals that exceed one context window become scheduling problems (note) - Some semantic subgoals exceed one context window, so they must be partitioned into smaller semantic judgments with symbolic collection, filtering, and staged summarization between them
• Semantic work can be relocated but not eliminated (note) - A meaning-dependent judgment is never removed, only placed — moved upstream where its inputs exist (amortized) or off a bottlenecked context (offloaded); 'free at use-time' always means paid earlier
• Session history should not be the default next context (note) - Storing execution history and loading it into the next agent call are separate decisions; chat and framework-owned tool loops conflate them by making session history the default next context
• Short composable notes maximize combinatorial discovery (note) - The library's purpose is to produce notes that can be co-loaded for combinatorial discovery — short atomic notes are a consequence of this goal; longer synthesized artifacts belong in workshops or derived instructions
• Silent disambiguation is the semantic analogue of tool fallback (note) - When an agent silently resolves unacknowledged material ambiguity in a spec, final success hides that the contract failed to determine the path — an extension of the tool-fallback observability problem
• Skill discovery re-fires in every sub-agent context, not just the top-level invocation (structured-claim) - Skill discovery is per-context and autonomous — every installed skill is re-matched in each sub-agent context, even ones a parent narrowed, so a delegating skill's own discoverability is a leak vector
• Skills are instructions plus routing and execution policy (note) - Skills add structured discovery, user-facing invocation, and declarative execution policy (tool permissions, model override, context isolation) beyond the shared procedure
• Skills derive from methodology (structured-claim) - The methodology→skill relationship is same-medium derivation, with the methodology retained as live fallback — distinct from codification and constraining
• Soft degradation often binds before the hard cap when required evidence fits (note) - For quality-sensitive agent work whose required evidence fits within the provider window, silent degradation across volume, complexity, and relevance/interference often constrains usable context before the hard cap
• Soft-bound traditions as sources for context engineering strategies (note) - Survey of twelve soft-bound traditions as candidate sources for context engineering strategies, with a three-tier assessment of what transfers, what's plausible, and what's blocked
• Solve low-degree-of-freedom subproblems first to avoid blocking better designs (note) - Ordering heuristic for decomposition: commit first to decisions with the fewest viable options, then place flexible choices around them to preserve global optionality.
• Source changes should surface downstream review targets, while reverse lineage can remain searchable (note) - Source-dependent artifacts need lineage signals when an upstream change may render those artifacts stale, regardless of where the lineage record is stored
• Spec mining is codification's operational mechanism (note) - Operationalizes codification by extracting deterministic verifiers from observed stochastic behavior — the mechanism that converts blurry-zone components into calculators
• Specification strategy should follow where understanding lives (note) - Among durable artifacts, spec-first, bidirectional spec, and spec mining fit different phases: when understanding is available upfront, discovered during execution, or only visible after observation
• Specification-level separation recovers scoping before it recovers error correction (note) - OpenProse-like DSLs expose control flow and discretion boundaries while leaving scheduling and validation on the LLM substrate, creating an intermediate regime between flat prompting and symbolic scheduling
• Stale indexes are worse than no indexes (note) - An agent trusts an index as exhaustive — a missing entry doesn't trigger search, it makes the note invisible
• Stale self-description conceals its own staleness (note) - What artifact drift adds when it is reflexive: the process that would detect it consults the artifact that drifted, the trigger has no edit event to hook, and synchronization load scales with autonomy
• Stateful tools recover control by becoming hidden schedulers (note) - Granting the strongest stateful-tool escape hatch shows that recovered control comes from relocating the scheduler into an exceptional tool or runtime, not from the framework loop itself
• Storing LLM outputs is constraining (note) - Keeping a specific LLM output resolves semantic underspecification and freezes one run against execution indeterminism - a constraining move applied to artifacts
• Structure activates higher-quality training distributions (note) - Structured templates like Evidence/Reasoning sections steer autoregressive generation toward higher-quality training data (scientific papers, legal analyses) rather than unstructured web text — the structure acts as a distribution selector
• Structured output is easier for humans to review (note) - Separated Evidence and Reasoning sections let human reviewers check facts and logic independently — a purely readability argument that doesn't depend on LLM behavior at all
• Subtasks that need different tools force loop exposure in agent frameworks (note) - When decomposition creates child tasks with different tool surfaces, the parent must construct fresh calls for each child, so a framework-owned loop is no longer the right control surface
• Synthesis is not error correction (note) - Synthesis propagates errors by merging all agent outputs; voting corrects errors by discarding minorities — Kim et al.'s 17.2× amplification is a synthesis failure, not evidence against multi-agent coordination
• System-definition artifacts are crystallized reasoning under context scarcity (note) - Separates heuristic rules that substitute for unavailable read-time reasoning from authority-bearing constraints and symbolic codification, which remain useful even with abundant context
• Systematic prompt variation serves verification and diagnosis, not explanatory-reach testing (note) - Controlled prompt variation either decorrelates checks or measures brittleness under fixed task semantics; Deutsch's variation test instead changes the explanation to test mechanism and explanatory-reach
• Tags (tag-readme) - Hub for all tag READMEs — browse the KB by conceptual domain rather than by directory; complete over the tag pages in this collection
• Technical constraints turn KB objective-function choice from philosophy into engineering (note) - Three technical constraints and the codification lever make KB objective-function choice testable engineering, not philosophy; goals set the loss, contracts and profiles specialize it, and oracle strength differs per profile
• Text testing framework — source material
• The augmentation-automation boundary is discrimination not accuracy (note) - Crossing from augmentation to automation requires per-instance discrimination, not aggregate accuracy — discrimination is empirically stagnant, so scaling capability alone cannot cross the boundary
• The bitter lesson selects against unearned reach, not against structure (note) - Scale replaces generalizations whose claimed scope was asserted from source-case fit rather than tested; structure whose reach was earned is what a scalable search converges on
• The bitter lesson selects production methods, not representational forms (note) - The lesson's axis is production method — hand-crafted versus search-and-learning — not representational form. Learned localized forms are therefore a coherent scaling hypothesis, with cross-artifact credit assignment as the decisive open problem
• The bitter-lesson defense portfolio has one load-bearing member for the form-only rebuttal (note) - The KB's bitter-lesson claims play different roles: one narrow answer to a form-only objection, an empirical burden, methodology, instrumentation, separate-objection answers, and conditional forecasts
• The boundary of automation is the boundary of verification (note) - Synthesis — oracle theory, labor economics, frontier-lab capability predictions, and supply-chain integrity evidence converge on verification cost as the primary structural determinant of automation
• The chat-history model trades context efficiency for implementation simplicity (note) - Chat history persists because appending messages preserves information and avoids interface design, but that convenience trades away selective loading under bounded context
• The deployed system, not the model alone, is the unit of learning (note) - Because prompts, retrieval, tools, and runtime policy jointly determine deployed behavior, model-only learning leaves consequential system choices fixed
• The four-field record exposes an efficiency, security, and sovereignty risk triad (note) - The four artifact-analysis fields exist to surface three architectural review concerns over retained behavior — efficiency, security, and sovereignty — with sovereignty (owner control to inspect, regenerate, delete, roll back) as the new axis
• The practical scheduler is the host language, not a reified select (note) - The simplest practical orchestration library demotes the tool loop to a returning, per-call-parameterized function and lets ordinary host-language code play select and K — reifying K only when the run must outlive its process or outgrow its memory
• The readable-artifact loop is the tractable unit for continual learning (note) - Identifies the natural-language-plus-symbolic pair as the tractable first loop for representational-form coevolution because it shares context, operates at current tempos, and already has a codification boundary
• The self-improving-system definition classifies its boundary cases without ad hoc exceptions (note) - Ten boundary cases run against the self-improving-system definition — each classifies by the stated criteria alone; the stress they apply falls on boundary declaration, not on the membership clauses
• The verifiability gradient (note) - Symbolic artifacts sit on a gradient from loose natural-language to deterministic code; higher-verifiability artifacts support tighter iteration loops, and learning moves artifacts along it in both directions
• The wikiwiki principle: lowest-friction capture, then progressive refinement in place (note) - Ward Cunningham's wiki design principle — minimize capture friction, refine in place — drives the text→note→structured-claim codification ladder
• Theory warrant should be tracked at the finest granularity evidence licenses (note) - Treat support for a theory as warrant for only the most specific claim, conjunction, model, and scope the evidence identifies; do not distribute joint warrant beyond what it entails without additional attribution
• Theory-mediated learning may improve sample efficiency under structured shifts (note) - Conjecture: learning that discovers, assesses, and revises addressable theories may need fewer target observations when a shift preserves the structure a theory names
• Theory-mediated self-improvement needs both interpretation and retention from one substrate (note) - Reflective self-improvement inherits the theory-mediated sample-efficiency conjecture only where one substrate both interprets a theory about the system's own operation and retains it addressably
• Three-space agent memory echoes Tulving's taxonomy but the analogy may be decorative (note) - The value of separating knowledge, self, and operational memory is that each has a different lifecycle — accumulation, slow evolution, and high churn; whether the Tulving mapping adds explanatory power beyond different retention policies is open
• Title as claim enables traversal as reasoning (note) - When note titles are claims rather than topics, following links between them reads as a chain of reasoning — the file tree becomes a scan of arguments, and link semantics (since, because, but) encode relationship types
• Title as claim exposes commitments, enabling Popperian maintenance (note) - When an index is a list of claims rather than topics, reviewing the KB becomes scanning hypotheses — each title exposes its commitment and invites the question "do I still believe this?" without opening the file
• Title as claim makes overlap between notes visible (note) - When note titles are claims, overlap between notes is visible at the index level — similar assertions are obvious without opening files; topical titles hide overlap behind different labels for the same territory
• Tool loop (tag-readme) - Index for the tool-loop argument — the framework-owned tool loop is useful but should yield control when tasks need different tool surfaces, exceed one context window, or codify scheduling
• Topology, isolation, and verification form a causal chain for reliable agent scaling (note) - Topology, isolation, and verification may form a strict dependency chain rather than independent design choices — tested against the simpler account that good decomposition implies the other two
• Trace-extracted memory earns authority per operation, not at capture (note) - Trace memories begin as records; verification, abstraction, and consultation earn authority under progressively harder oracles, while unverified stores accumulate guesses presented as knowledge
• Traditional debugging intuitions break when tool loops can recover semantically (note) - Programmers trained on traditional software expect broken infrastructure to fail loudly; semantic recovery in agent tool loops violates that expectation, so successful outcomes can create false confidence during debugging and maintenance
• Traditional software can bracket executor conformance; LLM systems cannot (note) - Wrongness is a relation to a norm, never intrinsic to a computation; classical stacks bracket the executor-conformance norm so every failure resolves to the spec, and LLM systems cannot, which is what generates the three-source deviation taxonomy
• Traversal improvements should be deferred via logging to avoid mid-task context switching (note) - Loading writing methodology into an already-committed context window is expensive; a one-line log entry preserves the improvement signal at near-zero cost and lets a separate pass do the fix
• Treat continual learning as representational-form coevolution (note) - Behaviour change spans distributed-parametric, natural-language, and symbolic forms, so the question is how their improvement loops relate — not which is the real locus of learning
• Two context boundaries govern collection operations (note) - Distinguishes the body-loading boundary from the later title-and-description index boundary, yielding three collection-size regimes with different consequences for areas, connect, and whole-KB work
• Type system (tag-readme) - Index of notes about the document type system — why types exist, what roles they serve, how they improve output quality, and how they're structured
• Type system enforces metadata that navigation depends on (note) - Descriptions don't appear spontaneously — they exist because the note base type requires them; without enforcement, metadata degrades and navigation collapses to opening every document
• Types give agents structural hints before opening documents (note) - Types and descriptions let agents make routing decisions without loading full documents — the type says what operations a document affords, the description filters among instances of that type
• Under sub-agent decomposition, feasibility is the heaviest fork's net load (note) - Shows why decomposition changes feasibility from total operation cost to the largest residual load left on any fork after work is shifted to siblings or the parent
• Underspecification and indeterminism complicate programming for prompts in distinct ways (note) - Indeterminism doubles test runs (statistical testing over distributions); underspecification doubles test targets (spec analysis for ambiguity). Conflating the two leads to misdiagnosis
• Unified calling conventions enable bidirectional refactoring between neural and symbolic (note) - When agents and tools share a calling convention, components can move between neural and symbolic without changing call sites — llm-do demonstrates this with name-based dispatch over a hybrid VM
• Unit testing LLM instructions requires mocking the tool boundary (note) - Skills are programs whose I/O boundary is tool calls — mocking that boundary creates controlled environments for testing whether instructions produce correct behavior, complementing text artifact testing with instruction-level regression detection
• Use tests a decomposition locally; retained rationale is what makes transfer testable (note) - Running a decomposition confirms only that it sufficed here; because many force-sets fit the same split, rationale retained at design time is what gives a transfer claim an antecedent to test
• Verification needs a typed target before it needs an oracle (note) - A check's warrant depends on a declared target class, so an unverifiable heterogeneous layer is usually blocked by missing artifact classification, not oracle difficulty — ontology precedes oracle
• Vibe-noting (note) - Linked, maintained knowledge artifacts let LLM agents recover reasoning across sessions, improving augmentation even when weak verification still blocks automation
• Warranted autonomy is bounded by oracle domain (note) - Bare autonomy is free, but warranted evaluation autonomy extends only to the candidates an oracle can assess with the required confidence
• Warranted reader update is the objective of substantive writing (note) - Defines epistemic interestingness as a relevant, warranted change relative to an intended reader's prior, making contribution selection—not accumulated inputs—the purpose of multistage writing.
• Weakly discriminated qualities tend to be underselected (note) - Conjecture separating available model capability from selection: qualities weakly distinguished by the actual acceptance oracle lose to strongly verified objectives
• Why directories despite their costs (note) - Directories buy one–two orders of magnitude of human-navigable scale over flat files, and enable local conventions per subsystem — but each new directory taxes routing, search config, skills, and cross-directory linking
• Why notes have types (note) - Seven roles of the type system — navigation hints, metadata enforcement, verifiable structure, local extensibility, content-layer identification, output quality through structured writing discipline, and maturation through constraining
• World models assess explanatory-reach through action-conditioned prediction (note) - Learned world models can assess explanatory-reach when action-conditioned predictions are tested across the interventions or shifts a commitment claims
• Writing conventions for kb/notes/ (theoretical profile)
• Writing styles are strategies for managing underspecification (note) - Maps descriptive, prescriptive, prohibitive, explanatory, and conditional context-file styles to distinct ways of narrowing agent interpretation, each trading constraint against generality