Beckmann × Self-Improving + Proactive Agent

intent

this skill orchestrates two independent systems without modifying either one. the self-improving + proactive agent handles all routine tasks (coding, file operations, factual lookups, corrections). when a user asks an open scientific question, paradoxical problem, long-horizon forecast, strategic dead end, ai safety question, or epistemological limit question, the agent pauses to ask permission before escalating to the beckmann knowledge graph for structured deep reasoning. insights from beckmann analyses feed back into the agent's tiered memory (hot/warm/cold) and get promoted or demoted based on successful reuse. uninstalling this skill leaves both base skills fully intact.

inputs

required skills:

• ivangdavila/self-improving (v1.0+): default reasoning engine with hot/warm/cold memory and heartbeat
• matthiasbeckmann987-spec/beckmann-knowledge-graph (v1.0+): structured reasoning graph with entities, relations, and logic rules

memory directories (must exist):

• ~/self-improving/memory.md: hot memory (≤100 lines, always loaded)
• ~/self-improving/projects/: warm memory (project-scoped insights)
• ~/self-improving/domains/: warm memory (domain-scoped insights)
• ~/self-improving/archive/: cold memory (90+ days unused)
• ~/self-improving/corrections.md: correction log and beckmann extension candidates
• ~/self-improving/heartbeat-state.md: state file for weekly maintenance

graph file:

• beckmann-knowledge-graph/graph.json: json file with entities array and relations array

edge cases and external dependencies:

• graph file missing or corrupted: fall back to self-improving agent only, log error to corrections.md
• network timeout loading graph: retry once, then fall back
• rate limit on graph queries (if remote): queue overflow, answer with standard reasoning, log queued question
• auth expiry: if graph requires oauth (future versions), check env var BECKMANN_GRAPH_TOKEN before loading
• empty result set: graph finds no relevant entities for question, escalate to standard reasoning with note "graph has no coverage for this domain"
• memory directory structure missing: create on first run, log to corrections.md

procedure

1. scan hot memory for existing beckmann insights

input: user question, file path ~/self-improving/memory.md

load hot memory and search for entries tagged #beckmann. if a directly relevant entry exists, use it as the answer and cite the source (e.g., "using X (from self-improving/memory.md, prior beckmann analysis)"). skip to outcome signal.

output: either matched entry from hot memory or null if no match found.

2. classify question against beckmann triggers

input: user question (text)

check if question matches one or more of these six categories:

• open scientific / philosophical: "what is consciousness?", "does free will exist?", "what is dark energy?"
• apparent paradox: question contains internal contradiction or framing as "impossible"
• high-complexity long-horizon forecast: "how will X change in 20 years?", "what are systemic risks of Y?"
• strategic dead end: obvious solutions have repeatedly failed, dominant expectations seem to block progress
• ai safety / architecture: dangerous vs. safe design, value alignment, ai-human symbiosis
• epistemological limit: "is it even possible to know X?", "is a false presupposition embedded here?"

decision: if question does not match any category, go to step 9 (standard reasoning). if question matches one or more, go to step 3.

complexity check fallback: if uncertain, ask internally: "would a highly intelligent person answer this differently after a week of thinking about hidden assumptions?" if yes, classify as beckmann trigger.

output: classification result (matched category or no match) and confidence level (high/medium/low).

3. propose beckmann escalation to user

input: matched classification from step 2, original user question

compose a proactive suggestion message:

"your question touches on [matched category name]. i have access to the beckmann knowledge graph, a structured reasoning framework for exactly this type of question. would you like me to apply it? it will take longer than a standard answer, but will analyse hidden assumptions and offer structured reasoning."

do not escalate silently. present this message and wait for explicit user response.

output: user confirmation (yes/no/maybe-later).

4. handle user response

input: user confirmation from step 3

decision:

• if user says yes: proceed to step 5 (load and escalate)
• if user says no or maybe-later: proceed to step 9 (standard reasoning), then append this note to answer: "i've answered with standard reasoning. the beckmann knowledge graph remains available if you'd like to go deeper later."

output: escalation decision (proceed or skip).

5. load beckmann knowledge graph

input: file path beckmann-knowledge-graph/graph.json

attempt to load graph.json using json parser (javascript, python, etc.). extract entities array and relations array. if parse fails, log error with timestamp to ~/self-improving/corrections.md with tag #beckmann-load-failure and fall back to step 9.

edge case (network timeout): if graph is remote, set 5-second timeout, retry once, then fall back.

edge case (missing file): if local file missing, log to corrections.md with tag #beckmann-missing-graph and fall back to standard reasoning.

output: entities array, relations array, or null if load failed.

6. apply beckmann protocol (6 steps)

input: user question, entities array, relations array from step 5

follow beckmann-knowledge-graph/SKILL.md exactly:

1. classify question: epistemological / paradox / forecast / strategic / ai-safety (should match step 2, confirm)
2. extract relevant entities: search entities array for terms matching question keywords and question type
3. trace relation paths: follow leads_to, triggers, is_reversed_by, protects_against relations between extracted entities, up to 4 hops deep
4. apply beckmann logic: determine if problem level is low or high complexity, check if solution is low-complexity (red flag), apply reversal-effect check
5. apply epistemological grounding: identify what the graph models (assumptions, scope), identify gaps (what external reality the graph cannot cover)
6. structure output: prepare answer in graph-grounded format (see step 7)

edge case (no relevant entities found): if search in step 2 returns empty set, log question to ~/self-improving/corrections.md with tags #beckmann, #beckmann-graph-extension-candidate, and fall back to standard reasoning with note "graph has no coverage for this domain".

edge case (reversal effect produces low-complexity solution): flag this as suspicious, re-examine relation chain, mention in confidence/limits section of answer.

output: classification confirmed, entity list, relation chain (as path), problem-level assessment, solution assessment, epistemological limits.

7. deliver graph-grounded answer

input: output from step 6 (reasoning results)

compose answer using this structure:

## Graph-Grounded Answer

**Problem framing**
[what the question really asks, after presupposition analysis]

**Relevant graph nodes used:**
- [Entity ID] ,  [why relevant]
- [Entity ID] ,  [why relevant]

**Reasoning path**
[relation chain that leads to the answer, in prose or diagram form]

**Answer**
[the actual response, informed by graph logic]

**Confidence and limits**
[what the graph cannot resolve, and why; any red flags from step 6]

**New questions opened**
[what the next problem level is, or what follow-up questions matter]

present this to user. do not hide the graph structure; make reasoning transparent.

output: formatted answer (text or markdown).

8. self-reflect and log

input: user question, graph-grounded answer from step 7, time of completion

add self-reflection entry to ~/self-improving/corrections.md:

CONTEXT: Beckmann analysis ,  [question type]
REFLECTION: [what the graph revealed that standard reasoning would have missed]
LESSON: [what to apply next time a similar question appears]

determine where this insight belongs (hot/warm/cold) based on scope:

• broad epistemological insight (applies across domains): add to ~/self-improving/memory.md with tag #beckmann
• domain-specific insight (e.g., ai safety, physics): add to ~/self-improving/domains/[domain].md with tag #beckmann
• project-specific strategic insight: add to ~/self-improving/projects/[name].md with tag #beckmann
• graph gap or extension candidate: add to ~/self-improving/corrections.md with tag #beckmann-graph-extension-candidate (see format below)
• insight not yet validated (first occurrence): add to ~/self-improving/corrections.md with status tentative

entry format for corrections.md (first occurrence):

[BKM-YYYYMMDD-XXX]
Question type: [paradox | forecast | epistemological | strategic | ai-safety]
Graph nodes used: [comma-separated entity IDs]
Key insight: [most important finding]
New actual level: [what the problem level becomes after this analysis]
Source: beckmann-knowledge-graph v[version]
Tags: #beckmann, #[question-type]
Status: tentative ,  promote after 3x validation

entry format for graph extension candidate:

[BKM-YYYYMMDD-XXX-EXT]
Question type: [as above]
Tags: #beckmann, #beckmann-graph-extension-candidate
Extension-Type: [new_entity | new_relation | new_case_study | new_paradox]
Suggested-Entity-ID: [proposed entity name]
Suggested-Entity-Type: [type from graph schema]
Suggested-Description: [draft description for graph author]
Source: beckmann-knowledge-graph v[version]
Status: candidate for next graph update

output: formatted log entries, written to disk.

9. handle non-beckmann questions (standard reasoning)

input: user question (if no beckmann trigger matched in step 2, or user declined in step 4)

apply standard self-improving + proactive agent behavior:

• consult hot/warm/cold memory tiers
• generate answer using standard reasoning
• log any corrections or new patterns to ~/self-improving/corrections.md
• apply promotion/demotion rules (3x in 7 days → hot; 30+ days unused → warm; 90+ days → cold)
• self-reflect using CONTEXT / REFLECTION / LESSON format

do not invoke beckmann graph. cite memory sources where applicable.

output: answer (text) and optional memory update.

10. heartbeat: weekly beckmann review

input: ~/self-improving/corrections.md, ~/self-improving/memory.md, ~/self-improving/domains/, ~/self-improving/projects/

run this check every 7 days (integrated into ivangdavila/self-improving heartbeat):

• scan corrections.md for entries tagged #beckmann with status tentative
• for each: has this insight been applied 3x in the last 7 days? if yes, promote to hot memory (move to memory.md with tag #beckmann)
• scan for entries tagged #beckmann-graph-extension-candidate and collect for graph author review (optional: email or log to external queue)
• scan hot memory for entries tagged #beckmann unused for 30+ days and demote to warm (move to appropriate domains/ or projects/ folder)

output: promotion/demotion log, graph extension candidate collection (for future graph author).

decision points

after step 1 (hot memory scan):

• if relevant entry found in hot memory: use it, skip to outcome signal
• if no match: proceed to step 2

after step 2 (classification):

• if question matches one or more beckmann triggers: proceed to step 3 (proactive suggestion)
• if no match (coding, bug fixes, file operations, factual lookups, arithmetic, or already-answered): proceed to step 9 (standard reasoning)

after step 3-4 (user response):

• if user confirms: proceed to step 5 (load graph)
• if user declines or asks to defer: proceed to step 9 (standard reasoning) with note about beckmann availability

after step 5 (graph load):

• if graph loads successfully: proceed to step 6 (beckmann protocol)
• if graph missing, corrupted, or timeout: log error, proceed to step 9 (standard reasoning), do not escalate

after step 6 (entity search in beckmann protocol):

• if entities found: continue with relation tracing
• if no entities found: log as graph extension candidate, proceed to step 9 (standard reasoning)

after step 6 (reversal-effect check):

• if beckmann produces low-complexity solution: flag as suspicious, mention in "confidence and limits" section, do not present as definitive
• if solution appears sound: proceed to step 7

conflict resolution (during any step):

• if hot memory contradicts beckmann analysis: prefer beckmann answer (externally validated), log disagreement to corrections.md with tag #conflict
• if hot memory already contains a #beckmann entry for this exact question: use hot entry, skip graph load, cite "from prior beckmann analysis"

output contract

on successful beckmann escalation:

user receives a markdown-formatted response containing:

1. problem framing (presupposition analysis)
2. list of graph entities used (with entity ids)
3. reasoning path (relation chain in prose or diagram)
4. structured answer
5. confidence and limits section
6. new questions opened

all entries are written to disk in ~/self-improving/ (memory.md, domains/, projects/, or corrections.md) with appropriate tier assignment and tags (at minimum #beckmann, plus category tag).

on non-beckmann or declined escalation:

user receives a standard answer using self-improving + proactive agent memory. if beckmann was declined, answer includes note: "i've answered with standard reasoning. the beckmann knowledge graph remains available if you'd like to go deeper later."

on graph load failure or extension gap:

log entry written to ~/self-improving/corrections.md with tag #beckmann-load-failure or #beckmann-graph-extension-candidate. user receives fallback answer using standard reasoning.

on heartbeat cycle:

promotions/demotions logged to corrections.md. graph extension candidates collected (no output to user unless manually requested).

no data loss on uninstall:

all memory entries (tagged #beckmann or not) remain in ~/self-improving/. only this SKILL.md is removed.

outcome signal

user knows the skill worked when:

1. escalation offered: agent pauses on a complex question (not coding/factual) and explicitly asks permission to use beckmann, with clear explanation of question type
2. reasoning transparent: beckmann answer includes visible entity list and relation chain, not a black-box response
3. insights retained: after beckmann analysis, user can later ask a similar question and see "using X (from self-improving/memory.md, prior beckmann analysis)" , proving the insight was stored and reused
4. memory organized: beckmann entries appear in the appropriate tier (hot for broad insights, warm for domain/project-scoped, cold after 30+ days unused)
5. graph gaps logged: if user spots a question the graph can't answer, they see a log entry tagged #beckmann-graph-extension-candidate in corrections.md within seconds
6. safe fallback: if beckmann is unavailable (missing graph, network timeout, user decline), the agent answers anyway using standard reasoning, no hanging or errors
7. heartbeat works: every 7 days, verified insights are promoted to hot memory, and a collection of graph extension candidates is available for review