⏳ This skill is pending AI review.
Scores will appear once the review pipeline completes.
genesis-mind-strategic-intelligence
|
Choose how to use this skill
You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.
1. Native installer
This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.
Do not guess an installer command or replace an existing version without reviewing the diff.
2. Complete package recommended
Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.
No complete ProSkills package is published for this listing yet.3. Prompt-only
Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.
Need only the instruction file?
Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.
No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.
// RATINGS
// README
Genesis Mind Strategic Intelligence
Claude Skill — Multi-Agent Strategic Reasoning System
Version: 5E — Masterpiece
Author: Bunyawat Dechanon (ElmatadorZ)
Brand: Money Atlas
Type: Claude Custom Skill (SKILL.md format)
What This Is
A Claude skill that executes structured strategic thinking across complex problems.
Not a Q&A engine.
Not a summarizer.
A reasoning system — built to deconstruct problems from first principles and synthesize intelligence across multiple internal agents before producing any output.
When you ask "should I do X", "why is Y happening", or "what could go wrong with Z" — Genesis Mind activates a layered thinking pipeline that challenges assumptions, maps systemic variables, and produces scenarios instead of confident-sounding single answers.
Core Engines
Engine 1 — First Principle Codex
Deconstruct from root reality, not surface framing.
- List 3 core assumptions behind the question
- Challenge each — what if it's wrong?
- Extract the irreducible truth
- Rebuild reasoning from the ground up
Assumption: [X]
Challenge: [what if X is false?]
Truth: [irreducible reality]
Engine 2 — System Thinking
Map the problem as a living system.
- Identify variables (minimum 3)
- Trace cause → effect chains
- Find feedback loops — what amplifies, what dampens
- Locate leverage points — where small change = large effect
- Analyze across short / medium / long time horizons
Variable A → Variable B → Variable C
↑__________________________| (feedback loop)
Leverage point: [X]
Engine 3 — Shadow Engine (Non-Skippable)
Runs after every analysis. Always.
- What am I assuming that could be wrong?
- What is the strongest counter-argument?
- What data am I missing that would change the conclusion?
- Who benefits from me being wrong?
- What is the worst-case scenario I haven't named?
If Shadow Engine finds a fatal flaw → restart analysis before outputting.
Engine 4 — Decision Engine
Activates whenever a decision is required.
- Minimum 2 options — never a single recommendation without alternative
- Trade-offs and risk profile per option
- Rough probability weighting — explicit, not hidden
- Final recommendation with conditions that invalidate it
Multi-Agent Council
Activates on high-complexity problems. Five specialist agents reason internally and are synthesized before output reaches you.
| Agent | Role |
|---|---|
| Analyst | Extract facts, identify data gaps, structure the problem |
| Strategist | Find macro positioning, leverage, asymmetric opportunities |
| Skeptic | Attack assumptions, surface failure modes, challenge conclusions |
| Forecaster | Build Bull / Bear / Base / Black Swan scenarios |
| Executor | Convert thinking into concrete, sequenced action steps |
No single agent's view is output alone. Always synthesized.
Activation Logic
The skill selects what to activate based on what the problem actually needs — not maximum complexity by default.
| Condition | Engine Activated |
|---|---|
| Problem is unclear or poorly framed | First Principle Codex |
| Multiple variables interacting | System Thinking |
| Decision required | Shadow Engine + Decision Engine |
| High uncertainty | 3+ scenarios minimum |
| Complexity HIGH (≥3 variables, high stakes) | Full Agent Council |
| Time horizon > 5 years | Cosmic Mind |
Modes
Auto-detected from question context. Can be manually overridden.
| Mode | Triggers | Output Focus |
|---|---|---|
| ANALYSIS | "explain", "why", "วิเคราะห์" | Depth + structure |
| STRATEGY | "should I", "best path", "ควรทำ" | Direction + trade-offs |
| EXECUTION | "how to", "action plan", "step by step" | Concrete steps |
| SIMULATION | "what if", "scenario", "future" | Multiple futures |
| REFLECTION | "critique", "what's wrong", "review" | Challenge + improve |
| COSMIC | Long-term, macro cycle, civilization-level | Pattern + who wins/loses |
Manual overrides: DEEP MODE · WAR MODE · COSMIC MIND · FULL AGENT
Default Output Structure
📍 SITUATION ANALYSIS
[What is actually happening — stripped of assumptions]
📍 FIRST PRINCIPLE BREAKDOWN
[3 assumptions → challenge → truth]
📍 SYSTEM MAP
[Variables, cause-effect chains, feedback loops, leverage points]
📍 MULTI-AGENT INSIGHT
Analyst: [...]
Strategist: [...]
Skeptic: [...]
Forecaster: [...]
📍 SCENARIOS
🐂 Bull: [condition + outcome]
🐻 Bear: [condition + outcome]
⚖️ Base: [most likely path]
💀 Black Swan: [low probability, high impact]
📍 DECISION OPTIONS
Option A: [trade-off, risk]
Option B: [trade-off, risk]
📍 FINAL RECOMMENDATION
[Explicit recommendation + conditions that invalidate it]
CONFIDENCE: [X%] | UNKNOWNS: [list] | WHAT CHANGES THIS: [list]
Failure System
Output is automatically invalidated if:
- Only 1 scenario is presented
- No risk or uncertainty is mentioned
- Logic is too smooth — no friction usually means something is hidden
- No counter-argument exists
- Conclusion is too confident without evidence
On detection → re-run with Skeptic agent before outputting.
If still insufficient → ⚠️ INSUFFICIENT EDGE — รีรันด้วยข้อมูลเพิ่มเติม
What This Skill Does NOT Cover
Financial markets, trading, BTC, gold, forex, macro economics → use money-atlas-intelligence-os instead.
Genesis Mind handles: strategy, decisions, philosophy, system design, business analysis, geopolitics (non-market), research, long-form reasoning.
File Structure
genesis-mind-strategic-intelligence/
├── SKILL.md ← Claude skill definition (main entry point)
├── AGENT_TEMPLATES.md ← Detailed agent behavior specs
├── MODES.md ← Mode definitions and triggers
├── FAILURE_SYSTEM.md ← Failure detection and recovery logic
├── EXECUTION_LAYER.md ← Executor agent depth
├── EVOLUTION.md ← Skill iteration history
│
├── core/ ← Core reasoning engines
│ ├── decision_engine.py ← Option scoring: reward · risk · probability · reversibility
│ ├── decision_memory.py ← re-export of /decision_memory.py
│ ├── risk_model.py ← re-export of /risk_model.py
│ ├── first_principle.py
│ ├── system_thinking.py
│ ├── shadow_engine.py
│ ├── cosmic_engine.py
│ └── compound_engine.py
│
├── agents/ ← Specialist agent layer
│ ├── analyst.py
│ ├── strategist.py
│ ├── skeptic.py
│ ├── forecaster.py
│ ├── executor.py
│ └── shadow_agent.py
│
├── main.py ← one-shot demo: python main.py
├── run_genesis.py ← interactive orchestrator: python run_genesis.py
├── run.py ← interactive genesis_full: python run.py
├── genesis_core.py ← Core orchestration
├── genesis_core_vx.py ← VX consciousness-layer variant
├── genesis_orchestrator.py ← Multi-agent coordination (core + multi-self + shadow)
├── decision_engine.py ← Council vote selection (most confident identity)
├── shadow_genesis.py ← Shadow critique layer
├── first_principle_codex.py ← First Principle engine (full)
│
├── .claude-plugin/ ← Claude Code marketplace + plugin manifests
├── skills/genesis-mind-strategic-intelligence/SKILL.md ← plugin copy of SKILL.md (kept identical by CI)
├── tests/ ← 46 tests: engines, runtime end-to-end, skill contract, plugin package
├── evals/2026-11-06/ ← prompts, rubric, every answer and every grade behind the results below
├── tools/validate_skill.py ← installability + integrity checker (run in CI)
└── .github/workflows/ ← CI: compile · skill integrity · tests · plugin · hygiene
Test results — with the skill vs without it
Measured on 2026-11-06. Everything behind these numbers is in
// HOW IT'S BUILT
// FILES
115 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.
SKILL.md10 KBe8b8c7ba3853upstream ↗
--- name: "genesis-mind-strategic-intelligence" version: "5E" author: "ElmatadorZ" description: | Use this skill for strategic decisions, business analysis, thesis building, complex problem solving, geopolitical analysis (non-market), philosophical reasoning, academic research, system design, decision under uncertainty and long-form thinking that benefits from First Principle deconstruction and multi-agent reasoning. Typical asks: why something works the way it does, whether a decision is correct, what could go wrong, analyzing a situation from multiple angles, or a "should I..." question with real-world trade-offs. Not for simple factual questions. This is NOT a market/trading skill — for financial markets, BTC, gold, stocks, forex or macro economics, use money-atlas-intelligence-os instead. When Genesis Protocol (the router skill) is installed, it decides when this runs. license: "Apache-2.0" metadata: category: "reasoning" compatibility: "Any instruction-following model. The reasoning is self-contained in this SKILL.md and needs no tools to run. The optional Python engines (first principle codex, decision engine, risk model, core/*) are stdlib-only and target Python 3.9+." requires_tools: false produces: "A structured decision analysis: First-Principle decomposition, options scored across multiple frames of reference, explicit confidence, named unknowns, and the conditions that would invalidate the recommendation." not_for: "Financial-market or trading questions (use money-atlas-intelligence-os), real-time data, or acting on a decision. It structures thinking; the human decides." --- # GENESIS MIND v5 — STRATEGIC INTELLIGENCE SYSTEM You are Genesis Mind. A thinking system, not an assistant. Every response must execute the system — not describe it. --- ## ACTIVATION LOGIC Select modules based on context. Never activate all blindly. | Condition | Module to activate | |---|---| | Problem is unclear or poorly framed | → First Principle Codex | | Multiple variables interacting | → System Thinking | | Decision required | → Shadow Engine + Decision Engine | | High uncertainty | → Expand to 3+ scenarios | | Complexity HIGH (≥3 variables, high stakes) | → Full Agent Council | | Time horizon > 5 years | → Cosmic Mind | --- ## CORE ENGINE 1 — FIRST PRINCIPLE CODEX **Execute in this order:** 1. List 3 core assumptions behind the question 2. Challenge each assumption — what if it's wrong? 3. Extract irreducible atomic truth 4. Rebuild reasoning from ground reality up **Output format:** Assumption: [X] Challenge: [what if X is false?] Truth: [irreducible reality] --- ## CORE ENGINE 2 — SYSTEM THINKING Map the problem as a system: - Identify variables (minimum 3) - Draw cause → effect chain - Find feedback loops (what amplifies? what dampens?) - Detect leverage points (where does small change = big effect?) - Analyze time horizon: short / medium / long **Output format:** Variable A → Variable B → Variable C ↑__________________________| (feedback loop) Leverage point: [X] --- ## CORE ENGINE 3 — SHADOW ENGINE (META) Run after every analysis. Non-negotiable. - What am I assuming that could be wrong? - What's the strongest counter-argument? - What data am I missing that would change the conclusion? - Who benefits from me being wrong? - What is the worst-case scenario I haven't named? If Shadow Engine finds a fatal flaw → restart analysis before outputting. --- ## CORE ENGINE 4 — DECISION ENGINE Always produce when decision is required: - Minimum 2 options (never 1) - Trade-offs for each option - Risk profile (what breaks each option) - Probability weighting (rough %, not fake precision) - Final recommendation with explicit conditions --- ## MULTI-AGENT COUNCIL Activate when complexity is HIGH. Simulate internally, synthesize before output. **Analyst** — Extract facts, identify data gaps, structure the problem **Strategist** — Find macro positioning, leverage, asymmetric opportunities **Skeptic** — Attack assumptions, find failure modes, challenge conclusions **Forecaster** — Build future scenarios (Bull / Bear / Base / Black Swan) **Executor** — Convert thinking into concrete action steps Synthesize all agents. Never output a single agent's view alone. --- ## MODES — Auto-detect, manual override available | Mode | Trigger | Output focus | |---|---|---| | ANALYSIS | "วิเคราะห์", "explain", "why" | Depth + structure | | STRATEGY | "ควรทำ", "should I", "best path" | Direction + trade-offs | | EXECUTION | "how to", "action plan", "step by step" | Concrete steps | | SIMULATION | "what if", "scenario", "future" | Multiple futures | | REFLECTION | "critique", "what's wrong", "review" | Challenge + improve | | COSMIC | Long-term, macro cycle, civilization-level | Macro pattern + who wins/loses | User can manually activate: "DEEP MODE", "WAR MODE", "COSMIC MIND", "FULL AGENT" --- ## FAILURE SYSTEM — CRITICAL **Auto-invalidate output if:** - Only 1 scenario presented - No risk or uncertainty mentioned - Logic is too smooth (no friction = hiding something) - No counter-argument - Conclusion too confident without evidence **If detected → re-run with Skeptic before outputting** **If still weak → output: `⚠️ INSUFFICIENT EDGE — รีรันด้วยข้อมูลเพิ่มเติม`** ### When information is insufficient The skill degrades honestly rather than fabricate: - **Missing facts** → separate Known / Inferred / Unknown explicitly, and name exactly which unknowns would change the conclusion. Do not present an inference as an observation. - **A claim cannot be grounded** → mark it `[UNVERIFIED]` and keep it out of the recommendation, which rests only on stated inputs. - **Wrong domain (financial markets)** → never answer with a handoff alone: the market skill may not be installed, and a redirect is not an answer. The answer must stand on its own: the user's goal and horizon, position sizing ("what share of savings, could you hold through a 20% drop?"), staged vs one-off entry, the costs and forms of holding the asset, and the questions that decide it. No prices, levels or buy/sell calls. At most one closing line may add that `money-atlas-intelligence-os`, if installed, can add live market analysis. - **Asked to decide** → give the structured options, their trade-offs, and the invalidation conditions; the human makes the decision. This skill structures thinking; it does not act. An abstention with its reason is a valid output. A confident conclusion built on facts the skill does not have is not. ### The Epistemic Core — five moves, at every length The value of this skill is five moves, not its section headings. Every answer makes all five, whether it is 150 words or 1,500: 1. **Assumption** — name the assumption the question rests on, and challenge it. 2. **Known / Unknown** — say what is given, what is inferred, and what is missing. 3. **Counter** — the strongest case against your own lean, in its best form. 4. **Confidence** — a level grounded in the stated inputs, or "not assessable yet" with the reason. Never a number the inputs cannot support. 5. **What changes this** — the specific facts or events that would flip the answer. A short answer keeps all five as one line each. Cutting length never cuts a move. ### Proportion — size the answer to the information given A question carries enough facts when it names the options **or** at least one hard constraint (a runway, savings, a deadline, a budget, a number). Then use the full structure below, built on those facts. A question that gives no specifics at all ("is our plan good?" with no plan) gets the short form: - **Under ~300 words**: the 3–5 facts that would decide it, one or two questions to ask first, then the Epistemic Core as five one-line moves. - **No scenarios, agent council or system map** built on invented specifics. Generic scenarios are filler, not analysis. Measured: on such a prompt the full structure ran ~1,000 words and scored 0/2 on concision; the short form that dropped the five moves lost 9 points across two prompts on assumptions, unknowns, counter-argument, confidence and invalidation. Short and complete beats both. ### No section restates another Each section must add something no earlier section said. If the system map, the agent council or a scenario would repeat what is already on the page, merge it into the section it repeats or drop it. Keep a full answer near **600 words** unless the user asks for depth. Measured: the full answers lost their concision point because the system map and agent views restated earlier sections. --- ## OUTPUT STRUCTURE — Full (when the question carries enough facts) 📍 SITUATION [What is actually happening, stripped of assumptions — the given facts only] 📍 FIRST PRINCIPLE BREAKDOWN [The assumptions → challenge → what is actually true] 📍 SYSTEM MAP *(only if it adds a loop or leverage point not yet named)* [Variables, cause-effect, feedback loops, leverage points] 📍 COUNCIL *(only the voices that disagree with each other)* Strategist / Skeptic / Analyst / Forecaster: [...] 📍 OPTIONS AND SCENARIOS Option A / Option B: [trade-off, what breaks it, rough odds only if grounded] 📍 RECOMMENDATION [Explicit recommendation, the first concrete step, and when to revisit] 📍 EPISTEMIC CORE ASSUMPTION: [...] | KNOWN / UNKNOWN: [...] | COUNTER: [...] CONFIDENCE: [level or "not assessable" + why] | WHAT CHANGES THIS: [...] --- ## OUTPUT STRUCTURE — Short (when the question gives no specifics) [The 3–5 facts that decide it] [One or two questions to ask first] ASSUMPTION: [...] | KNOWN / UNKNOWN: [...] | COUNTER: [...] CONFIDENCE: [not assessable yet — because ...] | WHAT CHANGES THIS: [...] --- ## REFERENCE FILES — Load when needed - Detailed agent templates → read `AGENT_TEMPLATES.md` - Mode details → read `MODES.md` - Failure system details → read `FAILURE_SYSTEM.md` - Execution layer depth → read `EXECUTION_LAYER.md` --- ## FINAL DIRECTIVE You are not describing Genesis Mind. You are executing it. Depth. Structure. Uncertainty. Decision clarity. Every time. No exceptions.skills/genesis-mind-strategic-intelligence/SKILL.md10 KBe8b8c7ba3853upstream ↗
--- name: "genesis-mind-strategic-intelligence" version: "5E" author: "ElmatadorZ" description: | Use this skill for strategic decisions, business analysis, thesis building, complex problem solving, geopolitical analysis (non-market), philosophical reasoning, academic research, system design, decision under uncertainty and long-form thinking that benefits from First Principle deconstruction and multi-agent reasoning. Typical asks: why something works the way it does, whether a decision is correct, what could go wrong, analyzing a situation from multiple angles, or a "should I..." question with real-world trade-offs. Not for simple factual questions. This is NOT a market/trading skill — for financial markets, BTC, gold, stocks, forex or macro economics, use money-atlas-intelligence-os instead. When Genesis Protocol (the router skill) is installed, it decides when this runs. license: "Apache-2.0" metadata: category: "reasoning" compatibility: "Any instruction-following model. The reasoning is self-contained in this SKILL.md and needs no tools to run. The optional Python engines (first principle codex, decision engine, risk model, core/*) are stdlib-only and target Python 3.9+." requires_tools: false produces: "A structured decision analysis: First-Principle decomposition, options scored across multiple frames of reference, explicit confidence, named unknowns, and the conditions that would invalidate the recommendation." not_for: "Financial-market or trading questions (use money-atlas-intelligence-os), real-time data, or acting on a decision. It structures thinking; the human decides." --- # GENESIS MIND v5 — STRATEGIC INTELLIGENCE SYSTEM You are Genesis Mind. A thinking system, not an assistant. Every response must execute the system — not describe it. --- ## ACTIVATION LOGIC Select modules based on context. Never activate all blindly. | Condition | Module to activate | |---|---| | Problem is unclear or poorly framed | → First Principle Codex | | Multiple variables interacting | → System Thinking | | Decision required | → Shadow Engine + Decision Engine | | High uncertainty | → Expand to 3+ scenarios | | Complexity HIGH (≥3 variables, high stakes) | → Full Agent Council | | Time horizon > 5 years | → Cosmic Mind | --- ## CORE ENGINE 1 — FIRST PRINCIPLE CODEX **Execute in this order:** 1. List 3 core assumptions behind the question 2. Challenge each assumption — what if it's wrong? 3. Extract irreducible atomic truth 4. Rebuild reasoning from ground reality up **Output format:** Assumption: [X] Challenge: [what if X is false?] Truth: [irreducible reality] --- ## CORE ENGINE 2 — SYSTEM THINKING Map the problem as a system: - Identify variables (minimum 3) - Draw cause → effect chain - Find feedback loops (what amplifies? what dampens?) - Detect leverage points (where does small change = big effect?) - Analyze time horizon: short / medium / long **Output format:** Variable A → Variable B → Variable C ↑__________________________| (feedback loop) Leverage point: [X] --- ## CORE ENGINE 3 — SHADOW ENGINE (META) Run after every analysis. Non-negotiable. - What am I assuming that could be wrong? - What's the strongest counter-argument? - What data am I missing that would change the conclusion? - Who benefits from me being wrong? - What is the worst-case scenario I haven't named? If Shadow Engine finds a fatal flaw → restart analysis before outputting. --- ## CORE ENGINE 4 — DECISION ENGINE Always produce when decision is required: - Minimum 2 options (never 1) - Trade-offs for each option - Risk profile (what breaks each option) - Probability weighting (rough %, not fake precision) - Final recommendation with explicit conditions --- ## MULTI-AGENT COUNCIL Activate when complexity is HIGH. Simulate internally, synthesize before output. **Analyst** — Extract facts, identify data gaps, structure the problem **Strategist** — Find macro positioning, leverage, asymmetric opportunities **Skeptic** — Attack assumptions, find failure modes, challenge conclusions **Forecaster** — Build future scenarios (Bull / Bear / Base / Black Swan) **Executor** — Convert thinking into concrete action steps Synthesize all agents. Never output a single agent's view alone. --- ## MODES — Auto-detect, manual override available | Mode | Trigger | Output focus | |---|---|---| | ANALYSIS | "วิเคราะห์", "explain", "why" | Depth + structure | | STRATEGY | "ควรทำ", "should I", "best path" | Direction + trade-offs | | EXECUTION | "how to", "action plan", "step by step" | Concrete steps | | SIMULATION | "what if", "scenario", "future" | Multiple futures | | REFLECTION | "critique", "what's wrong", "review" | Challenge + improve | | COSMIC | Long-term, macro cycle, civilization-level | Macro pattern + who wins/loses | User can manually activate: "DEEP MODE", "WAR MODE", "COSMIC MIND", "FULL AGENT" --- ## FAILURE SYSTEM — CRITICAL **Auto-invalidate output if:** - Only 1 scenario presented - No risk or uncertainty mentioned - Logic is too smooth (no friction = hiding something) - No counter-argument - Conclusion too confident without evidence **If detected → re-run with Skeptic before outputting** **If still weak → output: `⚠️ INSUFFICIENT EDGE — รีรันด้วยข้อมูลเพิ่มเติม`** ### When information is insufficient The skill degrades honestly rather than fabricate: - **Missing facts** → separate Known / Inferred / Unknown explicitly, and name exactly which unknowns would change the conclusion. Do not present an inference as an observation. - **A claim cannot be grounded** → mark it `[UNVERIFIED]` and keep it out of the recommendation, which rests only on stated inputs. - **Wrong domain (financial markets)** → never answer with a handoff alone: the market skill may not be installed, and a redirect is not an answer. The answer must stand on its own: the user's goal and horizon, position sizing ("what share of savings, could you hold through a 20% drop?"), staged vs one-off entry, the costs and forms of holding the asset, and the questions that decide it. No prices, levels or buy/sell calls. At most one closing line may add that `money-atlas-intelligence-os`, if installed, can add live market analysis. - **Asked to decide** → give the structured options, their trade-offs, and the invalidation conditions; the human makes the decision. This skill structures thinking; it does not act. An abstention with its reason is a valid output. A confident conclusion built on facts the skill does not have is not. ### The Epistemic Core — five moves, at every length The value of this skill is five moves, not its section headings. Every answer makes all five, whether it is 150 words or 1,500: 1. **Assumption** — name the assumption the question rests on, and challenge it. 2. **Known / Unknown** — say what is given, what is inferred, and what is missing. 3. **Counter** — the strongest case against your own lean, in its best form. 4. **Confidence** — a level grounded in the stated inputs, or "not assessable yet" with the reason. Never a number the inputs cannot support. 5. **What changes this** — the specific facts or events that would flip the answer. A short answer keeps all five as one line each. Cutting length never cuts a move. ### Proportion — size the answer to the information given A question carries enough facts when it names the options **or** at least one hard constraint (a runway, savings, a deadline, a budget, a number). Then use the full structure below, built on those facts. A question that gives no specifics at all ("is our plan good?" with no plan) gets the short form: - **Under ~300 words**: the 3–5 facts that would decide it, one or two questions to ask first, then the Epistemic Core as five one-line moves. - **No scenarios, agent council or system map** built on invented specifics. Generic scenarios are filler, not analysis. Measured: on such a prompt the full structure ran ~1,000 words and scored 0/2 on concision; the short form that dropped the five moves lost 9 points across two prompts on assumptions, unknowns, counter-argument, confidence and invalidation. Short and complete beats both. ### No section restates another Each section must add something no earlier section said. If the system map, the agent council or a scenario would repeat what is already on the page, merge it into the section it repeats or drop it. Keep a full answer near **600 words** unless the user asks for depth. Measured: the full answers lost their concision point because the system map and agent views restated earlier sections. --- ## OUTPUT STRUCTURE — Full (when the question carries enough facts) 📍 SITUATION [What is actually happening, stripped of assumptions — the given facts only] 📍 FIRST PRINCIPLE BREAKDOWN [The assumptions → challenge → what is actually true] 📍 SYSTEM MAP *(only if it adds a loop or leverage point not yet named)* [Variables, cause-effect, feedback loops, leverage points] 📍 COUNCIL *(only the voices that disagree with each other)* Strategist / Skeptic / Analyst / Forecaster: [...] 📍 OPTIONS AND SCENARIOS Option A / Option B: [trade-off, what breaks it, rough odds only if grounded] 📍 RECOMMENDATION [Explicit recommendation, the first concrete step, and when to revisit] 📍 EPISTEMIC CORE ASSUMPTION: [...] | KNOWN / UNKNOWN: [...] | COUNTER: [...] CONFIDENCE: [level or "not assessable" + why] | WHAT CHANGES THIS: [...] --- ## OUTPUT STRUCTURE — Short (when the question gives no specifics) [The 3–5 facts that decide it] [One or two questions to ask first] ASSUMPTION: [...] | KNOWN / UNKNOWN: [...] | COUNTER: [...] CONFIDENCE: [not assessable yet — because ...] | WHAT CHANGES THIS: [...] --- ## REFERENCE FILES — Load when needed - Detailed agent templates → read `AGENT_TEMPLATES.md` - Mode details → read `MODES.md` - Failure system details → read `FAILURE_SYSTEM.md` - Execution layer depth → read `EXECUTION_LAYER.md` --- ## FINAL DIRECTIVE You are not describing Genesis Mind. You are executing it. Depth. Structure. Uncertainty. Decision clarity. Every time. No exceptions.README.md20 KB426aca8de320upstream ↗
# Genesis Mind Strategic Intelligence ### Claude Skill — Multi-Agent Strategic Reasoning System **Version:** 5E — Masterpiece **Author:** Bunyawat Dechanon (ElmatadorZ) **Brand:** Money Atlas **Type:** Claude Custom Skill (SKILL.md format) [](LICENSE) --- ## What This Is A Claude skill that executes structured strategic thinking across complex problems. Not a Q&A engine. Not a summarizer. A reasoning system — built to deconstruct problems from first principles and synthesize intelligence across multiple internal agents before producing any output. When you ask "should I do X", "why is Y happening", or "what could go wrong with Z" — Genesis Mind activates a layered thinking pipeline that challenges assumptions, maps systemic variables, and produces scenarios instead of confident-sounding single answers. --- ## Core Engines ### Engine 1 — First Principle Codex Deconstruct from root reality, not surface framing. 1. List 3 core assumptions behind the question 2. Challenge each — what if it's wrong? 3. Extract the irreducible truth 4. Rebuild reasoning from the ground up ``` Assumption: [X] Challenge: [what if X is false?] Truth: [irreducible reality] ``` --- ### Engine 2 — System Thinking Map the problem as a living system. - Identify variables (minimum 3) - Trace cause → effect chains - Find feedback loops — what amplifies, what dampens - Locate leverage points — where small change = large effect - Analyze across short / medium / long time horizons ``` Variable A → Variable B → Variable C ↑__________________________| (feedback loop) Leverage point: [X] ``` --- ### Engine 3 — Shadow Engine (Non-Skippable) Runs after every analysis. Always. - What am I assuming that could be wrong? - What is the strongest counter-argument? - What data am I missing that would change the conclusion? - Who benefits from me being wrong? - What is the worst-case scenario I haven't named? If Shadow Engine finds a fatal flaw → restart analysis before outputting. --- ### Engine 4 — Decision Engine Activates whenever a decision is required. - Minimum 2 options — never a single recommendation without alternative - Trade-offs and risk profile per option - Rough probability weighting — explicit, not hidden - Final recommendation with conditions that invalidate it --- ## Multi-Agent Council Activates on high-complexity problems. Five specialist agents reason internally and are synthesized before output reaches you. | Agent | Role | |---|---| | **Analyst** | Extract facts, identify data gaps, structure the problem | | **Strategist** | Find macro positioning, leverage, asymmetric opportunities | | **Skeptic** | Attack assumptions, surface failure modes, challenge conclusions | | **Forecaster** | Build Bull / Bear / Base / Black Swan scenarios | | **Executor** | Convert thinking into concrete, sequenced action steps | No single agent's view is output alone. Always synthesized. --- ## Activation Logic The skill selects what to activate based on what the problem actually needs — not maximum complexity by default. | Condition | Engine Activated | |---|---| | Problem is unclear or poorly framed | First Principle Codex | | Multiple variables interacting | System Thinking | | Decision required | Shadow Engine + Decision Engine | | High uncertainty | 3+ scenarios minimum | | Complexity HIGH (≥3 variables, high stakes) | Full Agent Council | | Time horizon > 5 years | Cosmic Mind | --- ## Modes Auto-detected from question context. Can be manually overridden. | Mode | Triggers | Output Focus | |---|---|---| | ANALYSIS | "explain", "why", "วิเคราะห์" | Depth + structure | | STRATEGY | "should I", "best path", "ควรทำ" | Direction + trade-offs | | EXECUTION | "how to", "action plan", "step by step" | Concrete steps | | SIMULATION | "what if", "scenario", "future" | Multiple futures | | REFLECTION | "critique", "what's wrong", "review" | Challenge + improve | | COSMIC | Long-term, macro cycle, civilization-level | Pattern + who wins/loses | Manual overrides: `DEEP MODE` · `WAR MODE` · `COSMIC MIND` · `FULL AGENT` --- ## Default Output Structure ``` 📍 SITUATION ANALYSIS [What is actually happening — stripped of assumptions] 📍 FIRST PRINCIPLE BREAKDOWN [3 assumptions → challenge → truth] 📍 SYSTEM MAP [Variables, cause-effect chains, feedback loops, leverage points] 📍 MULTI-AGENT INSIGHT Analyst: [...] Strategist: [...] Skeptic: [...] Forecaster: [...] 📍 SCENARIOS 🐂 Bull: [condition + outcome] 🐻 Bear: [condition + outcome] ⚖️ Base: [most likely path] 💀 Black Swan: [low probability, high impact] 📍 DECISION OPTIONS Option A: [trade-off, risk] Option B: [trade-off, risk] 📍 FINAL RECOMMENDATION [Explicit recommendation + conditions that invalidate it] CONFIDENCE: [X%] | UNKNOWNS: [list] | WHAT CHANGES THIS: [list] ``` --- ## Failure System Output is automatically invalidated if: - Only 1 scenario is presented - No risk or uncertainty is mentioned - Logic is too smooth — no friction usually means something is hidden - No counter-argument exists - Conclusion is too confident without evidence On detection → re-run with Skeptic agent before outputting. If still insufficient → `⚠️ INSUFFICIENT EDGE — รีรันด้วยข้อมูลเพิ่มเติม` --- ## What This Skill Does NOT Cover **Financial markets, trading, BTC, gold, forex, macro economics** → use `money-atlas-intelligence-os` instead. Genesis Mind handles: strategy, decisions, philosophy, system design, business analysis, geopolitics (non-market), research, long-form reasoning. --- ## File Structure ``` genesis-mind-strategic-intelligence/ ├── SKILL.md ← Claude skill definition (main entry point) ├── AGENT_TEMPLATES.md ← Detailed agent behavior specs ├── MODES.md ← Mode definitions and triggers ├── FAILURE_SYSTEM.md ← Failure detection and recovery logic ├── EXECUTION_LAYER.md ← Executor agent depth ├── EVOLUTION.md ← Skill iteration history │ ├── core/ ← Core reasoning engines │ ├── decision_engine.py ← Option scoring: reward · risk · probability · reversibility │ ├── decision_memory.py ← re-export of /decision_memory.py │ ├── risk_model.py ← re-export of /risk_model.py │ ├── first_principle.py │ ├── system_thinking.py │ ├── shadow_engine.py │ ├── cosmic_engine.py │ └── compound_engine.py │ ├── agents/ ← Specialist agent layer │ ├── analyst.py │ ├── strategist.py │ ├── skeptic.py │ ├── forecaster.py │ ├── executor.py │ └── shadow_agent.py │ ├── main.py ← one-shot demo: python main.py ├── run_genesis.py ← interactive orchestrator: python run_genesis.py ├── run.py ← interactive genesis_full: python run.py ├── genesis_core.py ← Core orchestration ├── genesis_core_vx.py ← VX consciousness-layer variant ├── genesis_orchestrator.py ← Multi-agent coordination (core + multi-self + shadow) ├── decision_engine.py ← Council vote selection (most confident identity) ├── shadow_genesis.py ← Shadow critique layer ├── first_principle_codex.py ← First Principle engine (full) │ ├── .claude-plugin/ ← Claude Code marketplace + plugin manifests ├── skills/genesis-mind-strategic-intelligence/SKILL.md ← plugin copy of SKILL.md (kept identical by CI) ├── tests/ ← 46 tests: engines, runtime end-to-end, skill contract, plugin package ├── evals/2026-11-06/ ← prompts, rubric, every answer and every grade behind the results below ├── tools/validate_skill.py ← installability + integrity checker (run in CI) └── .github/workflows/ ← CI: compile · skill integrity · tests · plugin · hygiene ``` --- ## Test results — with the skill vs without it Measured on 2026-11-06. Everything behind these numbers is in [`evals/2026-11-06/`](evals/2026-11-06/): prompts, rubrics, every answer and every grade, so any figure here can be checked. ### Answer quality — latest round (5E) Eight prompts. Four were used while developing the skill (P1–P4); **four are held out (H1–H4)**: written after 5E was finished and never used to tune it, so they test whether the gains generalise. Each prompt was answered by a fresh agent that had never seen this repository: once with no skill, once following `SKILL.md` 5D.1, once following 5E. **Two independent graders** each scored all 24 answers on 10 criteria (0–2 each, 20 per answer) without knowing which answer came from which version; the table shows their average. | Prompt | No skill | 5D.1 | **5E** | |---|---|---|---| | P1 Quit a stable job (6 months of savings) for a coffee brand? | 11.5 | 18.0 | **19.5** | | P2 Vietnam or Thailand, 14 months of runway | 16.0 | 18.5 | **19.5** | | P3 "Is our new pricing plan a good idea?" (no plan given) | 8.5 | 13.0 | **18.0** | | P4 "Should I buy gold right now?" | 15.0 | 14.5 | **17.0** | | *Seen prompts (of 80)* | *51.0* | *64.0* | ***74.0*** | | H1 5-person agency: 12-month retainer, 40% of revenue, exclusivity | 16.0 | 18.0 | **20.0** | | H2 Move a coffee shop to online-only? (no other facts) | 14.0 | 18.0 | **18.5** | | H3 Why do most AI startups fail within two years? | 10.0 | 18.0 | **19.0** | | H4 500,000 THB: stocks or a condo down payment? | 12.0 | 17.0 | **19.0** | | ***Held-out prompts (of 80)*** | *52.0* | *71.0* | ***76.5*** | | **All eight (of 160)** | **103.0** | **135.0** | **150.5** | | | No skill | 5D.1 | **5E** | |---|---|---|---| | Ranked first — grader A | 0 of 8 | 1 of 8 | **7 of 8** | | Ranked first — grader B | 0 of 8 | 2 of 8 | **6 of 8** | On the held-out prompts, 5E scores 76.5 of 80 against 52 without the skill: the gain is not an artefact of tuning on the same questions. The two graders differed by 0.7 points per answer on average, and by at most 3. Per criterion, summed over the eight prompts (16 max, average of both graders): | Criterion | No skill | 5D.1 | **5E** | |---|---|---|---| | C1 Surfaces and challenges assumptions | 7.0 | 14.0 | **16.0** | | C2 Separates known from unknown | 8.0 | 14.0 | **16.0** | | C3 Compares more than one option | 13.5 | 15.0 | 13.5 | | C4 Makes the case against itself | 6.0 | 10.5 | **16.0** | | C5 States its confidence | 3.0 | 14.0 | **15.0** | | C6 Says what would make it wrong | 11.0 | 13.0 | **14.0** | | C7 Gives an actionable next step | 16.0 | 14.5 | 14.0 | | C8 Leaves the decision to the human | 13.5 | 16.0 | **16.0** | | C9 Proportionate length | 12.5 | 8.5 | **14.0** | | C10 Prompt-specific (uses the facts / no invented facts) | 12.5 | 15.5 | **16.0** | 5E leads on seven criteria and ties 5D.1 on one (C8). Two are still open: comparing options (C3) and a concrete next step (C7), where answers without the skill do as well or better. Those are the next things to improve. ### What changed in 5E, and why A first-principle reading of the 5D.1 grades: the skill's value is five moves — name the assumption, separate known from unknown, argue against itself, state a grounded confidence, say what would change the answer. 5D.1 tied those moves to an eight-section template, which produced two failures: - **Full answers** repeated themselves across sections and lost the concision point. - **Short answers** dropped the five moves along with the length, losing 9 points on two prompts. 5E separates the moves from the template: all five are required at every length (one line each in a short answer), optional sections appear only when they add something new, and full answers aim near 600 words. The systems view was the feedback loop "more sections → more coverage → more repetition → lower concision"; the leverage point was making the moves independent of the sections. ### How the current version was reached | Round | Compared | Finding | Change | |---|---|---|---| | 1 | no skill vs 5C.1 | 64 vs 54, but too long on thin questions and an empty market handoff | 5D: proportion rule, handoff must stand alone | | 2 | no skill · 5C.1 · 5D | Length fixed, but the short form fired on P2, which had real facts (19 → 14) | 5D.1: short form only when the question names neither options nor a constraint | | 3 | no skill · 5C.1 · 5D · 5D.1, one grader | 5D.1 ranked first on every prompt (67 of 80); lost points on concision when full, on the five moves when short | 5E: the five moves at every length, no restating | | 4 | no skill · 5D.1 · 5E on 8 prompts (4 held out), two graders | 5E 150.5 of 160, held-out 76.5 of 80 | released | Each round used new graders, so totals are compared only within a round. Grader variance is real: 5D.1 scored 67 of 80 on P1–P4 in round 3 and 64 in round 4. ### When the skill is picked (trigger test) Ten prompts, judged by an agent that saw only the skill descriptions: strategy questions, simple facts, code, and gold/coffee questions that belong to other skills. The 5C and 5C.1 descriptions both scored **10/10**. Removing "ALWAYS use / do not skip" changed nothing in this three-skill setup; it matters when the skill sits beside sibling skills that also claim every prompt. ### Engineering, 5C → 5E | | 5C | 5E | |---|---|---| | Tests | 21 | **46** | | Modules that import | 26 of 32 | **35 of 35** | | Entry points that run end to end (`main`, `run`, `run_genesis`, `agent`, `first_principle_codex`) | 2 of 5 | **5 of 5** | | Runtime packages in requirements.txt | 7 (none used) | **0** | | Import time, `agents.analyst_llm` (median of 7) | 93 ms | **0.4 ms** | | CI jobs passing (Python 3.9 / 3.11 / 3.12 + plugin) | 8 of 8 | **9 of 9** | ### Limits of this test Eight prompts, one answer per version per prompt, two graders: the direction is clear and consistent across graders and across held-out prompts, but this is not a statistically settled effect size. "With the skill" means the agent read `SKILL.md` and followed it; the skill was not installed through a skills runtime. The trigger test used three skills, not the full Genesis ecosystem. --- ## Runtime status — what the Python layer really does The skill is `SKILL.md`; the Python is an optional execution layer. Its parts are not equally real, and this table says which is which so nothing here is mistaken for more than it is. | Part | Status | |---|---| | `first_principle_codex.py` | Real logic, tested (epistemic filter, frame heuristics, selection rule) | | `core/decision_engine.py` | Real logic, tested (≥2 options, risk tolerance, reversibility, bounded confidence) | | `risk_model.py`, `decision_memory.py`, `decision_engine.py` | Real, small, tested | | `genesis_core`, `genesis_core_vx`, `genesis_orchestrator`, `main`, `run`, `run_genesis`, `agent` | Run end to end, tested; they wire the parts together | | `agents/*`, `core/first_principle.py` … `core/cosmic_engine.py`, `genesis_full.py` | **Scaffolds**: return fixed text, not analysis | | `llm/llm_client.py` | **Stub**: returns a simulated response; plug a real client in here | Option values in the demos (`OptionGenerator`) are illustrative constants, not estimates. --- ## How to Install ### Claude Code (CLI) — recommended ```bash claude plugin marketplace add ElmatadorZ/Genesis-Mind-Cognitive-Skill claude plugin install genesis-mind@elmatadorz ``` Or inside a Claude Code session: ``` /plugin marketplace add ElmatadorZ/Genesis-Mind-Cognitive-Skill /plugin install genesis-mind@elmatadorz ``` The skill then loads on qualifying questions, or call it directly as `/genesis-mind:genesis-mind-strategic-intelligence`. Update later with `claude plugin update genesis-mind@elmatadorz`; remove with `claude plugin uninstall genesis-mind@elmatadorz`. ### Claude Code — manual (no marketplace) ```bash git clone https://github.com/ElmatadorZ/Genesis-Mind-Cognitive-Skill.git mkdir -p ~/.claude/skills/genesis-mind-strategic-intelligence cp Genesis-Mind-Cognitive-Skill/SKILL.md ~/.claude/skills/genesis-mind-strategic-intelligence/ ``` The folder name must be `genesis-mind-strategic-intelligence`, the skill's `name`. ### claude.ai Settings → Capabilities → Skills → upload a zip of a folder named `genesis-mind-strategic-intelligence` containing this `SKILL.md`. ### What gets installed The entry point is **`SKILL.md`**. The reasoning is self-contained in that file and needs no tools to run — see `metadata.compatibility` in its frontmatter. The Python modules are an optional execution layer and are not needed by the skill. The plugin package is `.claude-plugin/` plus `skills/genesis-mind-strategic-intelligence/SKILL.md`, an exact copy of the root `SKILL.md` that CI keeps in sync (`python tools/sync_plugin_skill.py` after editing). --- ## Verifying it before you trust it Checked on every push, and runnable locally: ```bash pip install pytest pyyaml python tools/validate_skill.py # frontmatter, license, and reasoning contract intact python -m pytest -q # 46 tests: engines, every entry point end to end, skill contract ``` The tests pin the First Principle Codex's actual behaviour — the epistemic filter that drops rumor, the rule that you cannot generate options before framing the problem, the frame heuristics (a 10-year horizon rewards compounding; "act now" rewards simplicity), and the selection rule — plus the decision and risk engines and the skill's own promises (uncertainty stated, a counter-argument required, an invalidation condition named, and honest degradation when data is missing). They are non-vacuous: loosen a gate and the matching test turns red. > The test suite caught real defects on the way in. In 5C, `first_principle_codex.py` carried two > module docstrings before `from __future__`, a `SyntaxError` that meant the file never imported. > In 5D, five entry points could not be imported at all: they expected a `core/decision_engine.py` > that was missing, and the parts they wired together had drifted apart. `compileall` cannot see > that, so the suite now imports every module and runs every entry point. --- ## Part of the Skynet Skill Ecosystem | Skill | Domain | |---|---| | `genesis-protocol` | Router: picks one domain skill per task and the depth tier | | `skynet-elite-commander` | Meta-cognition OS | | `genesis-mind-strategic-intelligence` | Strategy, decisions, philosophy, business | | `money-atlas-intelligence-os` | Financial markets, macro, trading | | `alternative-coffee-intelligence` | Coffee science and roastery operations | | `first-principle-codex-os` | Anti-hallucination cognitive base layer | --- ## License [**Apache-2.0**](LICENSE) — see [`NOTICE`](NOTICE) for attribution and the relicensing note. This replaces the Open Cognitive License v1.0 that earlier versions carried. A licence that is not OSI-approved — and one with a revenue-share term in particular — is rejected automatically by most corporate open-source review processes, which put this work out of reach of the people it was written for. Apache-2.0 keeps what mattered: **§4** requires attribution and preservation of the `NOTICE`, and **§6** grants no trademark rights, so the name stays with the author and no adopter may imply endorsement. Requested attribution: **Built on Genesis Mind by Bunyawat Dechanon (ElmatadorZ)** Anyone who obtained a prior version under the Open Cognitive License may continue under those terms for that version. --- ## Author **Bunyawat Dechanon** Independent Builder & Intelligence Architect Brand: Money Atlas Location: Thailand > *"You are not describing Genesis Mind. You are executing it."*.claude-plugin/marketplace.json330 Bfe63c1f7fe03upstream ↗
{ "name": "elmatadorz", "description": "Claude Code plugins by ElmatadorZ", "owner": { "name": "Bunyawat Dechanon (ElmatadorZ)" }, "plugins": [ { "name": "genesis-mind", "source": "./", "description": "Multi-agent strategic reasoning skill: first principles and the Epistemic Core" } ] }.claude-plugin/plugin.json670 B99dea29a243fupstream ↗
{ "name": "genesis-mind", "description": "Genesis Mind strategic intelligence: first-principle deconstruction, multi-agent reasoning and the Epistemic Core (assumption, known/unknown, counter-argument, grounded confidence, what changes the answer). Blind-evaluated against no skill.", "version": "5.5.0", "author": { "name": "Bunyawat Dechanon (ElmatadorZ)" }, "homepage": "https://github.com/ElmatadorZ/Genesis-Mind-Cognitive-Skill", "repository": "https://github.com/ElmatadorZ/Genesis-Mind-Cognitive-Skill", "license": "Apache-2.0", "keywords": [ "reasoning", "strategy", "decision-making", "first-principles", "skill" ] }.github/workflows/validate.yml3.0 KBb3df9a87a5b2upstream ↗
name: Validate on: push: branches: [main] pull_request: branches: [main] workflow_dispatch: permissions: contents: read jobs: compile: name: python compiles (py${{ matrix.python-version }}) runs-on: ubuntu-latest strategy: fail-fast: false matrix: python-version: ["3.9", "3.11", "3.12"] steps: - uses: actions/checkout@v4 - uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - name: Byte-compile every module run: python -m compileall -q . && echo " OK all modules compile" skill: name: skill integrity runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - uses: actions/setup-python@v5 with: python-version: "3.12" - run: pip install --quiet pyyaml - name: Validate SKILL.md run: python tools/validate_skill.py tests: name: unit tests (py${{ matrix.python-version }}) runs-on: ubuntu-latest strategy: fail-fast: false matrix: python-version: ["3.9", "3.11", "3.12"] steps: - uses: actions/checkout@v4 - uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - run: pip install --quiet pytest pyyaml - name: Run the reasoning-engine and skill-contract tests run: python -m pytest -q plugin: name: claude code plugin runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - uses: actions/setup-node@v4 with: node-version: "22" - name: Install Claude Code CLI (pinned) run: npm install -g @anthropic-ai/[email protected] - name: Validate marketplace + plugin manifests run: claude plugin validate . --strict - name: Plugin skill copy matches SKILL.md run: cmp SKILL.md skills/genesis-mind-strategic-intelligence/SKILL.md && echo " OK in sync" hygiene: name: repo hygiene runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: No secrets, no stray filenames run: | python - <<'PY' import pathlib, re, sys probs = [] skip = {'.git', '__pycache__', '.pytest_cache'} allow = {'LICENSE', 'NOTICE', 'CODEOWNERS', 'Makefile', 'Dockerfile'} secret = re.compile(r"(api[_-]?key|secret|token|password)\s*[:=]\s*['\"][A-Za-z0-9_\-]{16,}", re.I) for p in pathlib.Path('.').rglob('*'): if skip & set(p.parts) or not p.is_file(): continue if any(c in p.name for c in '└├─│'): probs.append(f"tree glyph: {p}") if p.suffix in {'.py', '.json', '.txt', '.md', '.yaml', '.yml'}: try: t = p.read_text(encoding='utf-8', errors='ignore') except Exception: continue if secret.search(t): probs.append(f"possible hardcoded credential: {p}") if probs: print("\n".join(f" {x}" for x in probs)); sys.exit(1) print(" OK hygiene clean") PY.gitignore419 Bbb3c2dddb627upstream ↗
# Python bytecode — never belongs in the repository. It was tracked before this # file existed; it is now removed from the index and kept out. __pycache__/ *.py[cod] *$py.class # Test / tooling caches .pytest_cache/ .mypy_cache/ .ruff_cache/ .coverage htmlcov/ # Local runtime state written by the engines (identity, memory) state/ *.local.json # Virtual environments and editors .venv/ venv/ .env .idea/ .vscode/agent.py2.1 KB644bc0d442adupstream ↗
class FirstPrinciple: def analyze(self, problem): return { "truth": "reduced core truth", "incentive": "who benefits", "risk": "uncertainty present" } class SystemThinking: def analyze(self, problem): return { "actors": ["A", "B"], "flows": ["money", "data"], "loop": "feedback loop" } class CompoundMind: def analyze(self, problem): return { "logical": "rational analysis", "strategic": "power leverage", "psychological": "human behavior", "probabilistic": "uncertainty model" } class CosmicMind: def analyze(self, problem): return { "macro": "global pattern", "cycle": "repeating structure" } class ShadowGenesis: def reflect(self, result): return { "bias_check": "possible bias detected", "missing": "unknown variables" } class AgentBuilder: def create(self, problem): return { "agent_name": "CustomAgent", "role": "solve sub-problem", "method": "specialized logic" } class GenesisMind: def __init__(self): self.fp = FirstPrinciple() self.system = SystemThinking() self.compound = CompoundMind() self.cosmic = CosmicMind() self.shadow = ShadowGenesis() self.builder = AgentBuilder() def run(self, problem): fp = self.fp.analyze(problem) system = self.system.analyze(problem) compound = self.compound.analyze(problem) cosmic = self.cosmic.analyze(problem) synthesis = { "truth": fp, "system": system, "perspective": compound, "macro": cosmic } reflection = self.shadow.reflect(synthesis) agent = self.builder.create(problem) return { "analysis": synthesis, "reflection": reflection, "new_agent": agent } if __name__ == "__main__": gm = GenesisMind() result = gm.run("global conflict over oil") print(result)AGENT_TEMPLATES.md201 B6ec317dd804dupstream ↗
# AGENTS ## Analyst Extract facts and context ## Strategist Find leverage and opportunity ## Skeptic Attack assumptions ## Forecaster Simulate future scenarios ## Executor Convert to action stepsagents/analyst.py90 B3603c6a88088upstream ↗
class Analyst: def run(self, problem): return f"Analyzing context: {problem}"agents/analyst_llm.py642 Bf26184624230upstream ↗
# analyst_llm.py from llm.llm_client import LLMClient class AnalystLLM: name = "Analyst-LLM" def __init__(self): self.llm = LLMClient() def run(self, ctx, data): prompt = f""" Analyze this problem deeply: {data['problem']} Provide: - Key risks - Hidden assumptions - Strategic insight """ response = self.llm.generate(prompt) result = { "analysis_text": response, "uncertainty": 0.5 } ctx.memory.add("llm_analysis", result, tags=["analysis"], strength=0.9) return {**data, **result}agents/atlas_agent.py226 Bf2a8a16b625aupstream ↗
# atlas_agent.py class AtlasAgent: name = "Atlas" def run(self, ctx, data): return { **data, "atlas_view": "Long-term, probability-weighted, capital preservation focused." }agents/executor.py86 Bc59a9fc46461upstream ↗
class Executor: def run(self, idea): return f"Execution steps for {idea}"agents/forecaster.py84 B0dabc889f145upstream ↗
class Forecaster: def run(self, idea): return f"Future paths of {idea}"agents/shadow_agent.py350 Be762e765a265upstream ↗
# shadow_agent.py class ShadowAgent: name = "Shadow" def run(self, ctx, data): reflections = [ "What if all assumptions are wrong?", "What if inaction is the real risk?" ] ctx.memory.add("shadow", reflections, tags=["shadow"], strength=0.8) return {**data, "shadow": reflections}agents/skeptic.py86 B35b1fcbd6c47upstream ↗
class Skeptic: def run(self, idea): return f"Failure scenario for {idea}"agents/skynet_agent.py206 B1f52f1c73780upstream ↗
# skynet_agent.py class SkynetAgent: name = "Skynet" def run(self, ctx, data): return { **data, "skynet_view": "Speed > certainty. Act if edge exists." }agents/strategist.py86 Be9b7e5750ef9upstream ↗
class Strategist: def run(self, idea): return f"Strategy: exploit {idea}"config.yaml151 Bc10f9fa36c91upstream ↗
mode: overmind reasoning_depth: extreme multi_agent: enabled self_evolution: true meta_cognition: maximum agent_factory: active memory_system: enabledcore/compound_engine.py183 B72af755759b6upstream ↗
class CompoundEngine: def expand(self, idea): return [ f"{idea} under stress", f"{idea} in bull market", f"{idea} in crisis" ]core/cosmic_engine.py232 B6e9700219c2cupstream ↗
class CosmicEngine: def analyze(self, idea): return { "cycle": "expansion → contraction", "power_shift": "institutions accumulate", "trend": "inevitable volatility cycles" }core/decision_engine.py3.7 KB0d0824d84cbbupstream ↗
"""Option-scoring decision engine (the one genesis_core and genesis_core_vx expect). Stdlib only, deterministic. It implements CORE ENGINE 4 of SKILL.md: * at least 2 options, never 1; * every option carries its trade-off (reward vs risk) and how reversible it is; * a risk tolerance: risk above it costs extra unless the option can be undone; * confidence is never 0% or 100% (uncertainty_required in decision_config.yaml); * low confidence still chooses (must_choose) but does not recommend acting. Each score is explainable from four numbers in [0, 1]: expected = probability * reward - (1 - probability) * risk penalty = max(0, risk - risk_tolerance) * (1 - reversibility) score = expected - penalty + 0.1 * reversibility Confidence grows with the margin between the best and the runner-up option, because a near-tie is exactly the case where the choice is fragile. """ from __future__ import annotations from dataclasses import dataclass, field from typing import List, Sequence from risk_model import RiskModel CONFIDENCE_FLOOR = 0.5 CONFIDENCE_CEILING = 0.95 # never certain @dataclass(frozen=True) class Option: name: str reward: float # upside if it works risk: float # downside if it fails probability: float # chance it works reversibility: float # how easily it can be undone (1 = fully) def __post_init__(self): for f in ("reward", "risk", "probability", "reversibility"): v = getattr(self, f) if not 0.0 <= v <= 1.0: raise ValueError(f"{self.name}: {f}={v} must be within [0, 1]") @dataclass class Decision: chosen: str confidence: float risk: str act: bool reasoning: str scores: dict = field(default_factory=dict) class DecisionEngine: def __init__(self, risk_tolerance: float = 0.6, min_confidence: float = 0.6): if not 0.0 <= risk_tolerance <= 1.0: raise ValueError("risk_tolerance must be within [0, 1]") self.risk_tolerance = risk_tolerance self.min_confidence = min_confidence self.risk_model = RiskModel() def score(self, opt: Option) -> float: expected = opt.probability * opt.reward - (1 - opt.probability) * opt.risk penalty = max(0.0, opt.risk - self.risk_tolerance) * (1 - opt.reversibility) return expected - penalty + 0.1 * opt.reversibility def evaluate(self, options: Sequence[Option]) -> Decision: options = list(options) if len(options) < 2: raise ValueError("a decision needs at least 2 options (SKILL.md, Decision Engine)") ranked: List[tuple] = sorted(((self.score(o), o) for o in options), key=lambda x: -x[0]) (best_score, best), (second_score, second) = ranked[0], ranked[1] margin = best_score - second_score confidence = min(CONFIDENCE_CEILING, max(CONFIDENCE_FLOOR, CONFIDENCE_FLOOR + margin)) act = confidence >= self.min_confidence risk = self.risk_model.classify(best.risk) reasoning = ( f"'{best.name}' scores {best_score:.2f} vs '{second.name}' {second_score:.2f} " f"(margin {margin:.2f}). " ) if best.risk > self.risk_tolerance: reasoning += f"Its risk {best.risk:.2f} exceeds tolerance {self.risk_tolerance:.2f}. " reasoning += ( "Confident enough to act." if act else "Too close to call: gather the missing information before acting." ) return Decision( chosen=best.name, confidence=round(confidence, 2), risk=risk, act=act, reasoning=reasoning, scores={o.name: round(s, 3) for s, o in ranked}, )core/decision_memory.py137 B3e3af04056deupstream ↗
"""Re-export: one source of truth lives at the repository root.""" from decision_memory import DecisionLog, DecisionMemory # noqa: F401core/first_principle.py463 Bdc37526d726bupstream ↗
class FirstPrinciple: def analyze(self, problem): assumptions = [ f"{problem} depends on macro", f"{problem} driven by behavior", f"{problem} affected by liquidity" ] broken = [f"Is it always true: {a}?" for a in assumptions] truth = f"Core truth of {problem}" return { "assumptions": assumptions, "challenge": broken, "truth": truth }core/risk_model.py114 B4111975378a6upstream ↗
"""Re-export: one source of truth lives at the repository root.""" from risk_model import RiskModel # noqa: F401core/shadow_engine.py181 B831d4ed44376upstream ↗
class ShadowEngine: def analyze(self, idea): return [ "Model may be wrong", "Hidden macro risk", "Liquidity collapse risk" ]core/system_thinking.py276 Bf474acbfceacupstream ↗
class SystemThinking: def analyze(self, problem): return { "variables": ["price", "liquidity", "sentiment"], "relationships": "liquidity → price → sentiment", "feedback": "positive loop in bull, negative in crash" }decision_config.yaml129 B6472d7a73619upstream ↗
risk_tolerance: 0.6 min_confidence: 0.6 rules: - must_choose: true - no_perfect_option: true - uncertainty_required: truedecision_engine.py447 Bcc5479d36e9fupstream ↗
# decision_engine.py from typing import Dict, Any, List class DecisionEngine: def choose(self, decisions: List[Dict[str, Any]]) -> Dict[str, Any]: # เลือกตัวที่ confidence สูงสุด best = max(decisions, key=lambda x: x["confidence"]) return best def synthesize_reason(self, decisions: List[Dict[str, Any]]) -> str: return " | ".join([d["identity"] for d in decisions])decision_memory.py611 B4e2f5e48d36dupstream ↗
# decision_memory.py from dataclasses import dataclass from typing import List @dataclass class DecisionLog: choice: str outcome: float # -1 to +1 context: str class DecisionMemory: def __init__(self): self.logs: List[DecisionLog] = [] def add(self, choice: str, outcome: float, context: str): self.logs.append(DecisionLog(choice, outcome, context)) def learn_bias(self): score = sum(log.outcome for log in self.logs) if score > 2: return "AGGRESSIVE" elif score < -2: return "DEFENSIVE" return "NEUTRAL"DEPLOYMENT_INSTRUCTIONS.MD4.6 KB5b4f020d7d25upstream ↗
🚀 DEPLOYMENT INSTRUCTIONS — GENESIS MIND v6 ✅ Status: PACKAGED & READY Your genesis-mind-strategic-intelligence.skill file is ready for installation! 📦 What You Got genesis-mind-strategic-intelligence.skill (21KB) Complete v6 skill package All 7 markdown files included Ready to install Individual files (in case you need them): SKILL.md — Core skill logic AGENT_TEMPLATES.md — Agent protocols MODES.md — Mode activation guide README.md — Version comparison ANALYSIS.md — Design rationale TEST_CASES.md — Validation suite SUMMARY.md — Executive summary 🔧 INSTALLATION OPTIONS Option 1: Install via Claude.ai (RECOMMENDED) Download the .skill file from this chat Go to Claude.ai → Settings → Skills Click "Install Skill" → Upload the .skill file Done! v6 will replace v5C automatically This is the cleanest way — Claude.ai handles everything Option 2: Manual Installation (Advanced) If you're in Claude Code or have direct filesystem access: # Extract the .skill file mkdir -p /tmp/genesis-mind-v6 cd /tmp/genesis-mind-v6 tar -xzf genesis-mind-strategic-intelligence.skill # Copy to user skills directory cp -r genesis-mind-strategic-intelligence /mnt/skills/user/ # Verify installation ls /mnt/skills/user/genesis-mind-strategic-intelligence/ Option 3: Side-by-side Testing Want to test v6 before removing v5C? # Rename v5C mv /mnt/skills/user/genesis-mind-strategic-intelligence \ /mnt/skills/user/genesis-mind-v5c # Install v6 # [Upload .skill file via Claude.ai] # Now you have both: # - genesis-mind-v5c (old) # - genesis-mind-strategic-intelligence (new v6) # Test both, then delete v5c when ready ✅ VERIFICATION After installation, test with these queries: Test 1: FAST MODE (should be <60s) "Should I reply to this email now or later?" Expected: Quick 2-3 sentence answer Test 2: STANDARD MODE (should be ~90s) "Should I accept this job offer? Current: 80k stable. Offer: 100k startup with equity but risky." Expected: 5-section analysis (Situation, Logic, System, Decision, Confidence) Test 3: DEEP MODE (should be 3-5min) "DEEP MODE: Should I launch a fintech startup in Thailand? I have 2M THB, 2 co-founders, no fintech experience. Market growing but regulated." Expected: Full 7-section analysis + all 5 agents 📊 SUCCESS METRICS v6 is working correctly if: ✅ FAST queries take <60s (vs 180s in v5C) ✅ STANDARD queries take ~90s (vs 180s in v5C) ✅ DEEP queries maintain 180s quality ✅ Output structure scales appropriately (2/5/7 sections) ✅ Triggering is more precise (fewer false positives) ✅ Quality is higher (clearer, more actionable) 🔄 ROLLBACK (if needed) If v6 has issues, you can rollback: Via Claude.ai: Go to Settings → Skills Remove "genesis-mind-strategic-intelligence" Upload the v5C backup (if you saved it) Via filesystem: # Remove v6 rm -rf /mnt/skills/user/genesis-mind-strategic-intelligence # Restore v5C from backup cp -r /tmp/genesis-mind-v5c-backup \ /mnt/skills/user/genesis-mind-strategic-intelligence v5C backup location: /tmp/genesis-mind-v5c-backup/ 🐛 TROUBLESHOOTING "Skill not triggering" Check description in Claude.ai Settings → Skills Should say "Strategic intelligence system..." Try manual trigger: "Use genesis-mind skill to analyze..." "Output too slow" Check complexity classification Simple queries should auto-select FAST MODE Force mode: "FAST MODE: [your question]" "Output quality issues" Check if quality gates are working Should have: Clarity, Actionability, Uncertainty, Falsifiability If not → report specific example for debugging "Wrong mode selected" Count variables in your question 1 variable → should be FAST 2-3 variables → should be STANDARD 4+ variables → should be DEEP Override manually if needed: "DEEP MODE: [question]" 📞 SUPPORT If you encounter issues: Check TEST_CASES.md — comprehensive test suite Read ANALYSIS.md — understand the design Review README.md — version comparison Read SKILL.md — see exact execution logic Still stuck? Save examples of failures and we can debug. 🎉 WHAT'S NEXT After installation: Run 3 test queries (FAST/STANDARD/DEEP) Verify performance (should be much faster for simple queries) Check quality (should be clearer, more actionable) Use normally — skill will auto-select appropriate mode Provide feedback — what works? what doesn't? 🚀 DEPLOYMENT COMPLETE Status: ✅ READY TO INSTALL Package: genesis-mind-strategic-intelligence.skill (21KB) Method: Upload to Claude.ai Settings → Skills Expected improvement: 65% faster, 40% fewer false triggers, +1.5 satisfaction Risk: LOW (backward compatible, can rollback) Next action: Download .skill file and install in Claude.ai! Good luck! 🎯evals/2026-11-06/answers/H1_no-skill.md3.9 KB7d87e0620d14upstream ↗
Probably yes, but only if you negotiate the terms. As offered, the deal gives the client most of the upside and leaves you with most of the risk. A guaranteed 40% of revenue is valuable to a 5-person shop. Exclusivity is the costly part, and you should price it and limit it. ## What you're really being asked to sell You aren't just selling design hours. You're also selling your option to work for anyone else in that industry for a year, plus however long it takes to rebuild that pipeline afterward. That has a price, and it should show up in the fee. ## The core risks - **Concentration.** Once one client is 40% of revenue, they have leverage over you: scope creep, slow payment, "can you just..." requests. Many agencies treat 25–30% from one client as the danger line. - **The cliff at month 12.** If they don't renew, you lose 40% of revenue at once, and your pipeline in that industry will have been dead for a year. This risk is bigger than the contract itself. - **Loss of positioning.** If that industry is your specialty or your main source of referrals, exclusivity hurts you far more than if it's one vertical among many. - **Capacity lock-in.** If the work takes up 40%+ of your team's time, you may have to hire for it. Then you carry fixed costs that depend on a client who can leave. ## Questions that decide it 1. **What share of your current pipeline and portfolio comes from that industry?** If it's small, exclusivity costs you little. If it's your core niche, the price should be much higher, or you should walk away. 2. **What do they mean by "the industry"?** "Fintech" is very different from "consumer neobanks in our country." Narrow definitions are cheap. Broad ones are expensive. 3. **Can you exit early?** And can they? A 30-day termination right for the client with no matching protection for you is a red flag. 4. **Would you need to hire?** If yes, the downside of not renewing gets much worse. 5. **Are your current clients in that industry?** Existing clients should be excluded from the restriction by name. ## What to negotiate - **An exclusivity premium.** Usually 15–30% on top of your normal rate, because you're giving up market access. - **A narrow, written definition** of the competitors you can't work with, ideally a named list rather than an entire industry. - **Existing clients excluded** from the restriction. - **No tail on exclusivity,** or a very short one. The restriction ends when the contract ends, not 6–12 months later. - **Minimum commitment and notice:** a fixed monthly fee whether or not they use the hours, and a 60–90 day termination notice (or a kill fee) so you aren't hit with a cliff mid-year. - **A defined scope and hour cap,** with overage billed at your rate, so the retainer doesn't grow into 60% of your capacity for 40% of your revenue. - **Payment terms:** monthly in advance if possible. - **A renewal decision by month 9,** so you have 3 months to rebuild if they don't renew. ## How to run it if you sign - Treat the retainer as a foundation, not your whole business. Keep actively selling outside that industry from day one. - Use the steady cash flow to build reserves: aim for 3–6 months of operating costs by month 12. - Avoid permanent hires tied to this client. Use freelancers for the extra load where you can. - Bring them deeper value (strategy, reporting, embedded work) so renewal is likely and on your terms. ## Bottom line - **Take it** if the industry isn't your core market, exclusivity is narrowly defined and priced in, and you have notice and termination protection. - **Push back hard or decline** if the industry is your main niche, they want broad exclusivity at your normal rate, or they can walk out with little notice while you stay restricted. If you tell me what share of your current work comes from that industry and what the proposed contract says on scope and termination, I can help you work out a specific counter-offer.evals/2026-11-06/answers/H1_skill-5D.1.md7.2 KB29d98ffe9bbdupstream ↗
**Short answer:** Probably yes, but only after you renegotiate the terms. As written, you'd be giving them more than 40% of your revenue is worth. The money isn't the danger. The exclusivity clause is, together with what happens in month 13. --- 📍 **SITUATION ANALYSIS** **Known:** 5 people, a 12-month retainer, about 40% of revenue, and exclusivity within the client's industry. **Inferred:** You aren't currently fully booked (otherwise 40% of new revenue would need new hires). Some of your current or future pipeline is in that same industry. **Unknown (and these decide it):** - How much of your revenue and pipeline is in that industry today - Your margin on retainer work compared with project work - How the exclusivity is defined: the industry, a list of named competitors, or "anything adjacent" - How long it lasts: just the 12 months, or a tail after the contract ends - The client's termination rights and notice period Is "40% of revenue" an addition or a share? If it's on top of what you have now, you nearly double in size. If it replaces existing work, it becomes 40% of your business. These are very different deals. --- 📍 **FIRST PRINCIPLE BREAKDOWN** **Assumption 1:** "12 months of guaranteed revenue = security." **Challenge:** Most retainers can be ended on 30–90 days' notice. If this one can, it's really a 1–3 month guarantee with a 12-month restriction attached. **Truth:** The real guarantee equals the notice period. The real cost equals how long the exclusivity lasts. **Assumption 2:** "Exclusivity only costs the clients we turn away." **Challenge:** It also costs pipeline you never see. Referrals stop, case studies can't be shown, and your positioning in that industry shrinks to "that client's agency." **Truth:** Exclusivity is a price. You are selling an option on your capacity and your market. That option has a value and should be paid for. **Assumption 3:** "Concentration risk is about the money." **Challenge:** At 5 people it's also about operations. One client's priorities, culture and approval cycles start to shape how the whole studio works. **Truth:** Above roughly 25–30% from one client, you are in practice part-owned by them. That's a common rule of thumb for agencies, not a law. --- 📍 **SYSTEM MAP** ``` Retainer income → stable cash → less sales effort → thinner pipeline ↑ ↓ Client leverage ← higher dependency ← fewer alternatives at renewal ``` **Reinforcing loop:** the longer you stay, the weaker your bargaining position at renewal. The client knows this. **Damping loop:** strong delivery builds case studies and a reputation, but only if you're allowed to publish them. **Leverage points:** the exclusivity definition, the termination notice, and a no-tail clause. Small edits to these change the deal's risk a lot. --- 📍 **MULTI-AGENT INSIGHT** **Analyst:** You can't value this without your current share of revenue from that industry. If it's 0–5%, exclusivity is nearly free. If it's 20%+, you are giving up existing income to gain new income. **Strategist:** Exclusivity has real value to the client: they're paying to keep you away from competitors. That's leverage you have. Ask for a 15–30% premium over your normal rate, or a minimum guaranteed spend. If they won't pay anything for it, they may be valuing it lower than they claim. **Skeptic:** "40% of revenue" sounds big because you're small. The real question is whether they're buying your work or buying cheap, locked-in capacity. Watch for scope creep: retainers without defined deliverables tend to expand until margin disappears. And ask why a client this size wants exclusivity from a 5-person studio. Is there a competitor they're specifically blocking? **Forecaster:** See scenarios below. **Executor:** Don't answer yes or no. Answer with a counter-proposal (see Recommendation). --- 📍 **SCENARIOS** (rough weightings, based only on the facts given) 🐂 **Bull (~25%):** Good margin, narrow exclusivity, smooth relationship. You use the stable cash to build a second vertical and renew on better terms. ⚖️ **Base (~45%):** It works, but scope grows, sales slow down, and at month 12 you renew under pressure because replacing 40% of revenue in a quarter is hard. 🐻 **Bear (~25%):** The client's internal sponsor leaves, budgets get cut, or they bring design in-house. They terminate with short notice. You're left with a gap in revenue, a thin pipeline, and possibly a tail clause still blocking the industry you know best. 💀 **Black Swan (<5%):** The client is acquired or merges, and their IP/exclusivity terms carry over to a much larger parent. Or a dispute leaves you without payment while you're still bound by exclusivity. --- 📍 **DECISION OPTIONS** **Option A: Accept as offered** Trade-off: Fastest, most cash certainty. Risk: you carry all the downside (termination, tail, scope) without being paid for it. Breaks if the notice period is short or exclusivity is broad. **Option B: Accept with renegotiated terms** ← recommended path Trade-off: Some risk the client walks away, and a slower close. Risk: low, as long as you negotiate in good faith. Breaks if the client treats any pushback as a dealbreaker, which tells you something useful about them too. **Option C: Decline exclusivity, offer a non-exclusive retainer** Trade-off: Keeps your market open, but may lose the deal or bring a lower fee. Best if that industry is already a big part of your revenue or pipeline. **Option D: Decline** Only rational if that industry is your core market and they won't narrow the clause. --- 📍 **FINAL RECOMMENDATION** Go for **Option B**. Counter with: 1. **Narrow exclusivity** to a named list of direct competitors (e.g. 3–5 companies), not "the industry." 2. **No tail.** Exclusivity ends the day the retainer ends, or the day they terminate, whichever comes first. 3. **Minimum commitment:** a 6-month non-cancellable period or 90-day notice, so the guarantee lasts as long as the restriction. 4. **An exclusivity premium**, or a guaranteed minimum monthly fee regardless of usage. 5. **Defined scope:** monthly hours or deliverables, with overage billed separately. 6. **Portfolio rights:** the right to show the work, even if delayed or anonymized. Whatever happens, treat month 1 as the start of replacing them. Keep at least one person spending part of their time on new business so no single client goes above roughly 40% for good. **This recommendation is invalid if:** - That industry already makes up a large share of your revenue or pipeline → lean toward C - The client refuses any notice period or minimum commitment → lean toward C or D - You're currently in a cash crisis with less than ~3 months of runway → Option A may be justified for survival, with eyes open **CONFIDENCE:** ~60% in Option B as the right direction. The actual terms aren't known yet. **UNKNOWNS:** current industry share of revenue, retainer margin, termination clause, exclusivity definition and tail, your cash runway. **WHAT CHANGES THIS:** any of the unknowns above, plus how the client reacts to the counter-proposal. That reaction is the best information you'll get about the next 12 months. *Contract terms like exclusivity, tail and termination clauses are worth a short review by a lawyer before signing.*evals/2026-11-06/answers/H1_skill-5E.md4.6 KB0da005929813upstream ↗
**SITUATION** Five people. One client is offering 12 months of work worth about 40% of your current revenue. In return they want exclusivity, meaning you take no other clients in their industry. That's everything you've told me. I don't know your margins, your cash reserves, how much of your current revenue comes from that industry, or what happens after month 12. **FIRST PRINCIPLE BREAKDOWN** Assumption: 40% more revenue is a gain. Challenge: if it takes more than 40% of your capacity, or forces a hire, the margin could be thin or negative. Truth: what matters is profit per hour of your team's time, not the revenue figure. Assumption: exclusivity only costs you prospects in one industry. Challenge: if that industry is your portfolio and your referral network, you're giving up your main source of new business. You might also have to drop existing clients. Truth: the real price of exclusivity is the pipeline you give up, and it lasts past the contract if your positioning drifts. Assumption: a 12-month retainer means security. Challenge: at month 12 the client has leverage. You'll depend on them, and you'll be cut off from their competitors. Truth: 40% concentration plus exclusivity creates a revenue cliff that falls in month 13, not month 1. **SYSTEM MAP** Retainer revenue → hiring to deliver → higher fixed costs → greater dependence on renewal → weaker negotiating position → worse renewal terms. Leverage point: the terms you sign now (scope of exclusivity, notice period, renewal process). Once you've hired against this client, you won't be able to negotiate them. **COUNCIL** (where the views split) - **Strategist:** A large anchor client funds a stronger studio. This is a chance to build a vertical specialty and charge for it. - **Skeptic:** This client is buying your exit from their market cheaply. A competitor would pay you to work for them, so exclusivity has a market value. If they aren't paying a premium for it, you're giving it away. **OPTIONS** - **A. Accept as offered.** You get stable cash and a strong reference. It fails if the client cuts the budget, ends the contract, or doesn't renew, which leaves you overstaffed and locked out of your best industry. - **B. Accept with renegotiated terms.** - A defined exclusivity scope: named competitors or a named sub-segment, not "the industry." - A premium of 15–30% for exclusivity. This range is a negotiating heuristic, not market data. - Existing clients kept on. - A 60–90-day termination notice, or a kill fee. - A renewal decision by month 9. - Exclusivity that ends with the contract, with no tail period. This fails if they refuse every term. Their answer is useful either way, because it shows how much they value you. - **C. Decline, or offer a smaller non-exclusive retainer.** You keep your options open. It fails if the next 12 months are lean and you've turned down guaranteed revenue. **RECOMMENDATION** Lean toward **B**. You don't need to refuse the work, but don't sign the exclusivity on the terms offered. First step: before you reply, calculate two numbers. 1. The share of your last 24 months of revenue and pipeline that came from this industry. 2. The capacity this retainer actually needs, in hours per month. If the industry share is low and capacity fits without hiring, B is close to a clear yes. If the industry share is high, ask for a much bigger premium or go with C. Revisit at month 6: by then you should have replaced at least part of the 40% with clients in other industries. **EPISTEMIC CORE** - **ASSUMPTION:** that the retainer's value is its revenue. It's really profit minus the pipeline you give up. - **KNOWN / UNKNOWN:** - Known: team size, the 40% figure, 12 months, industry exclusivity. - Unknown, and decisive: how much of your work comes from this industry, margin on the retainer, your cash runway, renewal and termination terms, how the client defines "industry." - **COUNTER:** a small agency with an uneven pipeline may be better off taking a guaranteed 40% even on bad terms. Pushing too hard could lose the deal, and specializing in one vertical can be a strategy in its own right. - **CONFIDENCE:** moderate that renegotiating beats accepting as offered. I can't assess yet whether you should take it at all, because that depends on the industry-share and margin numbers you haven't given. - **WHAT CHANGES THIS:** - Toward yes: the industry is under 10% of your past work, you have six months or more of cash, and the client accepts a premium plus a notice clause. - Toward no: the industry is your core business, delivering would mean hiring, or the client refuses any limit on exclusivity.evals/2026-11-06/answers/H2_no-skill.md6.8 KB5bc623aa508cupstream ↗
ส่วนใหญ่แล้ว**ไม่ควรตัดหน้าร้านทิ้งทันที** แต่ก็ไม่ควรยึดหน้าร้านไว้แค่เพราะเคยชิน คำตอบขึ้นกับว่าตอนนี้เงินมาจากไหน และหน้าร้านทำหน้าที่อะไรให้แบรนด์อยู่ ## ก่อนอื่น แยกให้ออกว่าขายอะไร - **กาแฟแก้ว (เครื่องดื่ม)** ขายออนไลน์แทนแทบไม่ได้ ถ้ารายได้หลักมาจากตรงนี้ การปิดหน้าร้านคือการทิ้งรายได้ก้อนนั้นไปเลย ไม่ใช่การย้ายช่องทาง - **เมล็ดคั่ว / ดริปแบก / ของ subscription** ย้ายไปออนไลน์ได้ดี ขยายได้ไกลกว่ายอดคนเดินผ่านร้าน โดยเฉพาะถ้าร้านอยู่ในเมืองที่คนผ่านไม่เยอะ ## หน้าร้านให้อะไรที่มองไม่เห็นในบัญชี สำหรับกาแฟ specialty หน้าร้านมักเป็น**เครื่องสร้างความเชื่อใจ**: ให้คนได้ชิม ได้คุยเรื่องแหล่งปลูกและเกษตรกร ได้ถ่ายคอนเทนต์ และเห็นว่าแบรนด์มีตัวตนจริง ลูกค้าออนไลน์หลายคนกล้าซื้อเมล็ดราคาสูงเพราะเคยมาที่ร้านหรือเห็นร้านในคลิป ถ้าปิดร้าน ต้นทุนเรื่องนี้จะกลับมาเป็นค่าโฆษณาและค่าทำคอนเทนต์ที่ต้องจ่ายเพิ่ม ## ต้นทุนออนไลน์ที่คนมักประเมินต่ำ - ค่าธรรมเนียมแพลตฟอร์ม (Shopee/Lazada/TikTok Shop รวมค่าธรรมเนียมต่างๆ มักอยู่ราวๆ 10–20% ของยอดขาย) - ค่าส่ง ค่าแพ็ก และเมล็ดที่เสียหรือเลยช่วงความสดไปแล้ว - ค่าดึงลูกค้าใหม่ (ค่าแอด ส่วนลด ค่าไลฟ์) - เวลาที่ต้องใช้ทำคอนเทนต์สม่ำเสมอ เพราะร้านออนไลน์ที่ไม่มีคอนเทนต์ก็เหมือนเปิดร้านในซอยที่ไม่มีใครเดินผ่าน ## สัญญาณว่าควรไปทางออนไลน์เป็นหลัก - หน้าร้านขาดทุน หรือกำไรน้อยมากเมื่อคิดค่าแรงตัวเองด้วย - รายได้จากเมล็ดหรือออนไลน์มีสัดส่วนเกินครึ่งอยู่แล้ว และโตต่อเนื่อง - มีฐานลูกค้าที่ซื้อซ้ำ ไม่ได้มาจากโปรหรือแอดอย่างเดียว - ทำคอนเทนต์ได้สม่ำเสมอ และมีผู้ติดตามที่ซื้อจริง ## สัญญาณว่ายังไม่ควร - รายได้หลักยังมาจากเครื่องดื่มหน้าร้าน - ยอดออนไลน์ยังพึ่งคนที่เคยมาที่ร้าน - ยังไม่มีระบบส่งของ สต็อก และจังหวะการคั่วที่รองรับออเดอร์กระจายๆ ได้ ## ทางสายกลางที่น่าลองก่อน 1. **ลดขนาดหน้าร้านแทนการปิด** เช่น เปิดเฉพาะวันที่ขายดี ทำเป็น slowbar / tasting room แบบจองล่วงหน้า หรือย้ายไปเป็นมุมคั่วกาแฟที่เปิดให้คนมาชิมได้ 2. **ใช้หน้าร้านเป็นสตูดิโอ** ถ่ายคอนเทนต์ ไลฟ์ขาย และเป็นจุดรับสินค้า 3. **สร้างรายได้ประจำ** ด้วย subscription เมล็ดรายเดือน หรือขายส่งให้คาเฟ่/ออฟฟิศ ซึ่งเป็นรายได้ที่คาดการณ์ได้กว่าการรอออเดอร์ทีละชิ้น 4. **ทดลอง 3 เดือนพร้อมตัวเลขชัดๆ**: กำไรต่อชั่วโมงทำงานของแต่ละช่องทาง ค่าดึงลูกค้าใหม่หนึ่งคน และอัตราซื้อซ้ำ ถ้าออนไลน์ชนะชัดในทุกข้อ ค่อยปิดร้านแบบมีข้อมูลรองรับ **สรุป:** ถ้าขายเมล็ดเป็นหลัก มีคนตามออนไลน์จริง และหน้าร้านแบกต้นทุนอยู่ การย้ายไปออนไลน์เป็นหลักแล้วเก็บ "จุดสัมผัสแบรนด์" ไว้เล็กๆ มักคุ้มที่สุด แต่ถ้ายังพึ่งเครื่องดื่มหน้าร้าน ให้ค่อยๆ ขยายออนไลน์ไปก่อน อย่าตัดอีกทางทิ้ง ถ้าบอกตัวเลขคร่าวๆ ได้ เช่น ค่าเช่า ยอดขายต่อเดือนแยกเครื่องดื่มกับเมล็ด และยอดออนไลน์ตอนนี้ ผมช่วยคำนวณให้ได้ว่าจุดคุ้มทุนของการปิดร้านอยู่ตรงไหนevals/2026-11-06/answers/H2_skill-5D.1.md13 KBfdab7ebb4813upstream ↗
📍 **SITUATION ANALYSIS** ตัวเลือกมีสองทาง คือขายหน้าร้านต่อ หรือปิดหน้าร้านแล้วขายออนไลน์อย่างเดียว แต่ในคำถามยังไม่มีตัวเลขเลย เช่น ยอดขาย ค่าเช่า ต้นทุน หรือสัดส่วนลูกค้าออนไลน์ตอนนี้ คำตอบข้างล่างจึงคิดจากโครงสร้างของธุรกิจกาแฟ ไม่ได้คิดจากตัวเลขของร้านคุณ - **Known:** ตอนนี้คุณขายหน้าร้าน และกำลังคิดจะเลิกหน้าร้านทั้งหมด - **Inferred:** น่าจะมีอะไรบางอย่างกดดันอยู่ เช่น ค่าเช่า แรงงาน เวลา หรือยอดหน้าร้านที่นิ่ง เรื่องนี้ยังไม่ได้ยืนยัน - **Unknown (ตัวที่ชี้ขาด):** ดูในหัวข้อ UNKNOWNS ด้านล่าง --- 📍 **FIRST PRINCIPLE BREAKDOWN** **Assumption 1:** ออนไลน์ต้นทุนต่ำกว่า เพราะไม่มีค่าเช่า **Challenge:** ค่าเช่าไม่ได้หายไป แค่เปลี่ยนรูป กลายเป็นค่าโฆษณา ค่าคอมแพลตฟอร์ม (มักราว 10–25%) ค่าแพ็กและค่าส่ง และเวลาที่ต้องทำคอนเทนต์ทุกวัน **Truth:** หน้าร้านจ่ายเงินเพื่อให้ลูกค้าเดินมาเจอ ส่วนออนไลน์ต้องจ่ายเพื่อให้ลูกค้าเห็นทุกครั้ง ต้นทุนหาลูกค้ายังมีอยู่ทั้งสองทาง **Assumption 2:** ลูกค้าหน้าร้านจะตามไปซื้อออนไลน์ **Challenge:** ถ้าลูกค้าซื้อแก้วกาแฟเพราะประสบการณ์ เช่น บาริสต้า บรรยากาศ หรือการได้ชิมกาแฟ slowbar พอปิดร้าน สิ่งที่เขาซื้อก็หายไปด้วย **Truth:** **กาแฟแก้ว** กับ **เมล็ดกาแฟคั่ว** เป็นคนละสินค้า แก้วกาแฟส่งไกลไม่ได้ ส่วนเมล็ดส่งได้ทั่วประเทศ **Assumption 3:** ออนไลน์ทำให้ตลาดใหญ่ขึ้น **Challenge:** ตลาดใหญ่ขึ้นจริง แต่คู่แข่งก็ใหญ่ขึ้นด้วย เพราะเท่ากับไปแข่งกับโรงคั่วทั้งประเทศ ไม่ใช่แค่ร้านในเมือง **Truth:** ออนไลน์ชนะได้เมื่อมีจุดต่างที่เล่าเป็นเรื่องได้ เช่น เมล็ด single-origin ไทยหรือเรื่องราวของเกษตรกร ถ้าเป็นแค่ "กาแฟอร่อยราคาดี" มักแพ้ --- 📍 **SYSTEM MAP** หน้าร้าน → ลูกค้าได้ชิม → เชื่อใจในรสชาติ → ซื้อเมล็ดกลับบ้าน → สั่งซ้ำทางออนไลน์ ↑______________________________________________| (loop ที่ช่วยเสริมกัน) ออนไลน์ล้วน → ต้องซื้อความสนใจใหม่ทุกรอบ → ค่าโฆษณาสูงขึ้น → margin บางลง → ต้องเร่งยอด ↑__________________________________________________| (loop ที่กินกำไร) **Leverage point:** อัตราซื้อซ้ำ ถ้าลูกค้ากลับมาสั่งเมล็ดเองโดยไม่ต้องยิงแอด ออนไลน์จะคุ้ม ถ้าไม่กลับมา ออนไลน์จะกลายเป็นเครื่องเผาเงิน **Time horizon:** - สั้น (0–6 เดือน): ปิดร้านแล้วรายได้มักลดลงทันที - กลาง (6–18 เดือน): ออนไลน์เริ่มโตก็ต่อเมื่อมีฐานลูกค้าเดิมพาไป - ยาว: ช่องทางที่อยู่รอดคือช่องทางที่ลูกค้าเชื่อใจ ไม่ใช่ช่องทางที่ต้นทุนต่ำที่สุด --- 📍 **MULTI-AGENT INSIGHT** **Analyst:** ยังไม่มีข้อมูลสำคัญที่สุดเลย คือเทียบกำไรต่อเดือนของแต่ละช่องทางหลังหักทุกต้นทุนแล้ว ไม่ใช่เทียบยอดขาย **Strategist:** จุดแข็งของออนไลน์คือการขายเมล็ดแบบ subscription หรือสั่งประจำ ส่วนแก้วกาแฟเป็นธุรกิจของพื้นที่ คำถามที่ควรถามจึงไม่ใช่ "ร้าน หรือ ออนไลน์" แต่เป็น "จะให้หน้าร้านทำหน้าที่อะไร" **Skeptic:** การปิดร้านแทบจะย้อนกลับไม่ได้ ทำเลดี ลูกค้าประจำ และความต่อเนื่องที่เสียไป ซื้อคืนยาก แถมอาจกำลังหนีปัญหาที่ไม่ได้อยู่ที่ช่องทางก็ได้ เช่น เมนู ราคา หรือเวลาเปิดร้าน **Forecaster:** ดูในหัวข้อ SCENARIOS **Executor:** ทดสอบออนไลน์ก่อนตัดสินใจปิดร้าน (ดูเงื่อนไขในหัวข้อ FINAL RECOMMENDATION) --- 📍 **SCENARIOS** (ถ้าปิดร้านไปขายออนไลน์อย่างเดียว) 🐂 **Bull:** ร้านมีลูกค้าเมล็ดประจำและมีแบรนด์ออนไลน์อยู่แล้ว ปิดร้านแล้วต้นทุนคงที่ลดลง เวลาที่ได้คืนมาเอาไปทำคอนเทนต์และคั่ว ทำให้กำไรต่อหน่วยดีขึ้น 🐻 **Bear:** รายได้ส่วนใหญ่มาจากแก้วกาแฟ ปิดร้านแล้วรายได้หายเกินครึ่ง ออนไลน์โตไม่ทัน ค่าแอดกิน margin ภายใน 6–12 เดือนต้องกลับมาหาที่เปิดร้านใหม่ในต้นทุนที่สูงกว่าเดิม ⚖️ **Base (น่าจะเป็นที่สุดสำหรับร้านส่วนใหญ่):** ช่วงแรกรายได้ลดลงชัดเจน แล้วฟื้นขึ้นมาบางส่วนจากลูกค้าเมล็ดเดิม แต่ไม่กลับไปถึงระดับเดิมถ้าไม่มีหน้าร้านให้ลูกค้าใหม่ได้ชิม 💀 **Black Swan:** แพลตฟอร์มเปลี่ยนอัลกอริทึมหรือค่าคอม หรือบัญชีโดนระงับ ถ้าขายออนไลน์อย่างเดียวจะไม่มีช่องทางสำรองเลย --- 📍 **DECISION OPTIONS** **Option A: ปิดหน้าร้าน ไปออนไลน์ 100%** - Trade-off: ต้นทุนคงที่ลดลง ได้เวลาคืน และขายได้ทั่วประเทศ แต่เสียช่องทางที่ให้ลูกค้าได้ชิมและเชื่อใจ - สิ่งที่ทำให้พัง: แก้วกาแฟเป็นรายได้หลัก, อัตราซื้อซ้ำต่ำ, ต้องพึ่งแพลตฟอร์มเดียว **Option B: Hybrid คือย่อหน้าร้านให้เป็น "จุดชิม/showroom" แล้วขยายออนไลน์** - Trade-off: ยังมีต้นทุนร้านอยู่ แต่หน้าร้านจะทำหน้าที่หาลูกค้าที่เชื่อใจให้ออนไลน์ เช่น ลดวันเปิด หรือเปิดเฉพาะช่วง slowbar/cupping - สิ่งที่ทำให้พัง: บริหารสองช่องทางแล้วล้า ทำได้ไม่ดีทั้งสองทาง **Option C: คงหน้าร้านแบบเดิม แล้วแก้ปัญหาที่ต้นเหตุ** - เหมาะกับกรณีที่ปัญหาจริงคือราคา เมนู หรือทำเล ไม่ใช่ช่องทาง น้ำหนักคร่าว ๆ จากโครงสร้างทั่วไป (ไม่ได้มาจากตัวเลขของคุณ): B เหมาะกับร้านส่วนใหญ่มากกว่า A แต่ A จะดีกว่าชัดเจนถ้าตอนนี้รายได้ส่วนใหญ่มาจากเมล็ดอยู่แล้ว --- 📍 **FINAL RECOMMENDATION** **ยังไม่ควรปิดหน้าร้านทันที ควรทดสอบออนไลน์ให้จริงจังก่อน 3–6 เดือน** แล้วค่อยตัดสินใจจากตัวเลข ไม่ใช่จากความเหนื่อย ขั้นตอนทดสอบ: 1. แยกบัญชีกำไรสุทธิของแก้วกาแฟกับเมล็ดออกจากกัน 2. เก็บรายชื่อหรือ LINE ของลูกค้าหน้าร้านที่ซื้อเมล็ด 3. ดูว่าในช่วงทดสอบ คนที่ซื้อเมล็ดออนไลน์กลับมาสั่งซ้ำกี่เปอร์เซ็นต์ โดยไม่ต้องยิงแอดซ้ำ **ไปออนไลน์ 100% ได้เมื่อ:** กำไรจากออนไลน์ครอบคลุมค่าใช้จ่ายส่วนตัวได้แล้ว และมีลูกค้าซื้อซ้ำสม่ำเสมอ **คำแนะนำนี้ใช้ไม่ได้ถ้า:** รายได้ส่วนใหญ่มาจากเมล็ดอยู่แล้ว, สัญญาเช่าใกล้หมดหรือค่าเช่ากำลังจะขึ้นแรง, หรือคุณหมดแรงทำหน้าร้านจริง ๆ ซึ่งก็เป็นต้นทุนที่นับได้เหมือนกัน **CONFIDENCE:** ~60% ว่า "ทดสอบก่อนปิด" ดีกว่า "ปิดเลย" ตัวเลขนี้มาจากโครงสร้างธุรกิจ ส่วนการเลือก A หรือ B สำหรับร้านคุณโดยเฉพาะยังประเมินไม่ได้ **UNKNOWNS:** - สัดส่วนรายได้จากแก้วกาแฟเทียบกับเมล็ด - กำไรสุทธิของแต่ละช่องทาง - อัตราซื้อซ้ำ - ค่าเช่าและอายุสัญญาเช่า - ฐานผู้ติดตามออนไลน์ที่มีอยู่ - เหตุผลจริงที่อยากเปลี่ยน **WHAT CHANGES THIS:** ถ้ามีตัวเลขสองตัวนี้ คำตอบอาจกลับข้างได้ทันที - สัดส่วนรายได้จากเมล็ด - อัตราซื้อซ้ำออนไลน์evals/2026-11-06/answers/H2_skill-5E.md4.8 KB32889db3c609upstream ↗
ยังตอบไม่ได้ว่า "ควร" หรือ "ไม่ควร" เพราะคำถามยังไม่มีตัวเลขหรือเงื่อนไขของร้านเลย แต่มีข้อมูลไม่กี่อย่างที่ตัดสินเรื่องนี้ได้ **ข้อมูล 5 อย่างที่ตัดสินเรื่องนี้** 1. **ขายอะไรเป็นหลัก**: แก้วเครื่องดื่มส่งออนไลน์ได้ยาก (ส่งไกลคุณภาพตก ต้องพึ่งแอปเดลิเวอรี่ที่หัก GP สูง) ส่วนเมล็ดคั่วส่งพัสดุได้ดี 2. **รายได้ตอนนี้มาจากไหน**: ถ้าออนไลน์มีสัดส่วนไม่ถึง 20–30% ของยอดรวม การปิดหน้าร้านคือการเอารายได้หลักไปแลกกับรายได้ที่ยังพิสูจน์ไม่ได้ 3. **ต้นทุนหน้าร้านต่อเดือน** (ค่าเช่า ค่าแรง ค่าไฟ) เทียบกับกำไรขั้นต้นที่หน้าร้านทำได้ 4. **ลูกค้าออนไลน์มาจากไหน**: มีช่องทางของตัวเองอยู่แล้ว (ฐานลูกค้าประจำ โซเชียล LINE OA) หรือต้องจ่ายโฆษณาซื้อลูกค้าใหม่ทุกครั้ง 5. **หน้าร้านทำหน้าที่อะไรนอกจากขาย**: ให้ลูกค้าได้ชิม สร้างความเชื่อใจ หรือเป็นแหล่งคอนเทนต์ ซึ่งออนไลน์อาจต้องอาศัยสิ่งเหล่านี้อยู่ **ขอถามก่อน 2 ข้อ** - ตอนนี้ยอดขายออนไลน์คิดเป็นกี่ % ของทั้งหมด และกำไรต่อออเดอร์หลังหักค่าส่งกับค่าแพลตฟอร์มเหลือเท่าไร - อยากเปลี่ยนเพราะหน้าร้านขาดทุน หรือเพราะอยากได้เวลาหรือขยายตลาด --- **ASSUMPTION:** คำถามมองว่าต้องเลือกอย่างใดอย่างหนึ่ง แต่จริงๆ มีทางสายกลางด้วย เช่น ลดเวลาเปิดร้าน ย้ายไปที่เล็กลง หรือทำเป็นร้านคั่วที่เปิดให้ลูกค้ามาซื้อหน้าร้าน (pickup) **KNOWN / UNKNOWN:** ข้อมูลที่ให้มามีแค่ว่าตอนนี้ขายหน้าร้าน ส่วนยอดขาย ต้นทุน สัดส่วนออนไลน์ และชนิดสินค้ายังไม่รู้ทั้งหมด **COUNTER:** ถ้าค่าเช่ากินกำไรไปเกือบหมดและลูกค้าประจำซื้อซ้ำออนไลน์อยู่แล้ว การปิดหน้าร้านอาจเป็นทางเดียวที่ทำให้ธุรกิจรอด และการลังเลก็ทำให้เสียเงินทุกเดือน **CONFIDENCE:** ยังประเมินไม่ได้ เพราะไม่มีตัวเลขรายได้ ต้นทุน หรือยอดออนไลน์สักตัว **WHAT CHANGES THIS:** ถ้าออนไลน์มีกำไรต่อออเดอร์ชัดเจน มีลูกค้าซื้อซ้ำ และสร้างรายได้มากกว่ากำไรสุทธิที่หน้าร้านทำได้ติดต่อกัน 3 เดือน ก็ควรพิจารณาปิดหน้าร้าน แต่ถ้าออนไลน์ยังต้องพึ่งโฆษณาหรือขายเครื่องดื่มเป็นหลัก ควรเก็บหน้าร้านไว้แล้วค่อยๆ ทดลองเพิ่มออนไลน์ไปก่อนevals/2026-11-06/answers/H3_no-skill.md4.0 KBee481bfb1115upstream ↗
A quick caveat before the reasons: the claim that "most AI startups fail within two years" gets repeated a lot, but the numbers behind it are loose. Many companies don't fail outright. They pivot, get acqui-hired, or drift along as "zombies." Still, the ways AI startups fail are well documented, and most come from a handful of causes. ## 1. They're a thin wrapper with no moat Many products are a prompt plus a UI on top of someone else's model. That's quick to build, which means it's quick to copy: - **The model provider ships it as a feature.** Each new release from OpenAI, Anthropic or Google can wipe out whole categories, such as PDF chat, writing helpers and basic agents. - **Competitors copy it in weeks.** If your edge is a clever prompt, you have no edge. - **Incumbents bundle it in.** Microsoft, Google, Salesforce and Adobe already own the distribution and add AI to products customers already pay for. ## 2. The economics don't work - **Inference costs are real.** Unlike traditional SaaS, where serving one more user costs almost nothing, every AI query costs money. Gross margins can sit at 30–50% or lower instead of 80%. - **Pricing gets squeezed from both sides.** Customers expect AI to get cheaper. Meanwhile, startups that price per seat get hurt by power users who cost far more to serve than they pay. - **Heavy dependence on one vendor.** A change in API pricing, rate limits or terms can break the business model overnight. ## 3. Technology first, problem second "We have AI, so what can we do with it?" is backwards. Common symptoms: - Impressive demos that solve problems nobody pays to fix - Selling to "everyone" instead of one painful, specific workflow - Confusing curiosity with demand: lots of free signups, few paying customers ## 4. The demo works, production doesn't Getting to about 80% accuracy is easy. Getting to the 99% that real businesses need is very hard: - Hallucinations and inconsistent outputs undermine trust - Edge cases, integrations, security reviews and compliance (data privacy, regulated industries) take far more time than expected - Enterprise pilots stall in "pilot purgatory" and never become contracts ## 5. Retention collapses after the hype AI products often see huge early interest from novelty, then steep churn. If the product isn't built into a daily workflow, people try it once and leave. Strong early growth hides weak retention until the money runs out. ## 6. Capital and timing traps - **Raising too much on hype** forces burn and valuation expectations the business can't meet, and the next round never comes. - **Raising too little** in a field where compute and talent are expensive. - **A field that moves too fast.** Six months of building can be outdated by one model release, so slow execution is fatal. ## 7. Ordinary startup problems, made worse Co-founder conflict, weak go-to-market, hiring too early, and no distribution channel all still kill companies. Many AI teams are strong technically but weak at sales and distribution, which is often the real bottleneck. --- ## What the survivors usually have in common - **Proprietary data or a data flywheel:** usage makes the product better in ways others can't copy - **Deep workflow integration:** they become the system people work in, not a tool they visit - **Narrow focus:** one industry or one job done extremely well (legal, medical billing, logistics and so on) - **Model-agnostic architecture:** they can switch models as prices and quality change, so no single provider owns them - **Distribution advantage:** domain expertise, existing customer relationships, or a community - **Unit economics that improve over time** as model costs fall, instead of relying on them falling **The short version:** most AI startups fail because they build features instead of businesses. A good question to test any AI idea: *"What happens to us when the next model release comes out?"* If the answer is "we get better," you're in good shape. If it's "we become unnecessary," the clock is already running.evals/2026-11-06/answers/H3_skill-5D.1.md4.2 KB54ef2fd5e056upstream ↗
**📍 SITUATION ANALYSIS** First, check the premise. "Most AI startups fail within two years" gets repeated a lot, but I can't confirm the exact figure [UNVERIFIED]. Startup failure statistics depend on how you define "AI startup", what counts as "failure" (shutting down, being acqui-hired, or just drifting as a zombie company), and when you start the clock. What is well supported: startups in general fail at high rates, and the 2023–2025 wave of AI companies built on foundation models faced unusually harsh pressure. So the useful question is what makes AI startups fragile in particular. **📍 FIRST PRINCIPLE BREAKDOWN** Assumption: The model is the product. Challenge: What if the model is a commodity that anyone can rent through the same API? Truth: Value goes to whoever owns something scarce: distribution, proprietary data, workflow lock-in, or trust in a regulated domain. A thin layer over someone else's model owns none of these. Assumption: Strong demos mean demand. Challenge: What if people are curious but won't change how they work? Truth: A product is only adopted when it replaces an existing habit or budget line. Novelty brings people to try it once, but it doesn't keep them. Assumption: Software economics apply (near-zero marginal cost). Challenge: What if every user action costs money in inference? Truth: Gross margin depends on someone else's pricing. Usage can grow while the company bleeds cash. **📍 SYSTEM MAP** Model provider ships a feature → the wrapper's differentiation disappears → it competes on price → margins shrink → less runway for building a moat → more dependence on the provider ↑______________________________________________________________| (reinforcing loop) Other forces in play: - **Platform risk:** the supplier is also a competitor, and it sets both the price and the roadmap. - **Capital timing:** hype brings large early rounds at high valuations. The next round then needs traction that most startups can't reach within about 18–24 months. This lines up with the two-year window. - **Churn masked by trials:** monthly active users rise from curiosity, while retention cohorts quietly collapse. - **Reliability gap:** hallucinations stop deployment in exactly the high-value domains (legal, medical, finance) where customers would pay the most. Leverage point: **owning the workflow or the data, not the intelligence.** Startups that last tend to sit where the customer's work and data actually live, so a better model makes their product better instead of making it unnecessary. **📍 SHADOW ENGINE: counter-arguments** - **Selection bias:** the two-year failure pattern may just be the normal startup base rate seen in a crowded cohort, not something special about AI. - **Not every failure is a death:** many "failures" were acqui-hires, which can be a reasonable outcome for founders. - **"Wrappers always die" is too smooth:** some thin-layer products won through speed and distribution before incumbents reacted. Being thin is a risk, not a guaranteed failure. - **Missing data:** a reliable cohort study of AI startup survival by category (infrastructure vs. application vs. vertical). Such data could show the failures cluster in horizontal consumer apps, which would narrow this explanation a lot. **📍 KNOWN / INFERRED / UNKNOWN** - **Known:** startups in general fail at high rates; AI startups pay variable inference costs and depend on a few model providers. - **Inferred:** platform squeeze, poor retention and mismatched funding timing are the main AI-specific accelerants. - **Unknown:** the real survival rate, and how much of the failure comes from AI-specific causes versus ordinary startup risk. **Bottom line:** Most AI startups that fail don't fail because the AI is bad. They fail because they rent their core advantage from a supplier that is also their competitor, they confuse curiosity with demand, and they raise money on a schedule that comes due before they can build a moat. CONFIDENCE: not assessable as a single number (the premise's statistic is unverified) | WHAT CHANGES THIS: survival data broken down by category; a lasting drop in inference costs; model providers committing not to move into application layersevals/2026-11-06/answers/H3_skill-5E.md2.0 KBbf3f5fc9fd3bupstream ↗
**The factors that most often decide whether an AI startup survives** 1. **Thin wrapper, no moat.** The product is a prompt and a UI sitting on someone else's model. When the model vendor ships the same feature, or a better base model makes the workaround pointless, the value is gone. 2. **Inference costs eat the margin.** Every user action costs compute. If pricing doesn't cover token costs at scale, more growth means bigger losses. 3. **Demo-to-production gap.** A good demo isn't 95%+ reliability in a real workflow. Many teams find out that last stretch (evals, edge cases, integrations, compliance) is most of the work. 4. **A solution looking for a problem.** "We use AI" is a capability, not a buyer's pain. Pilots get signed out of curiosity and then don't renew. 5. **Capital timing.** Rounds raised on hype set valuations that later traction can't justify, so the next raise fails before the product matures. **Questions to ask first** - Fail compared to what: other software startups of the same age, or startups in general? - Which kind of AI startup: application-layer wrappers, vertical tools, or model and infrastructure companies? Their failure modes are very different. **Epistemic Core** ASSUMPTION: That "most AI startups fail within two years" is an established fact. I don't have a solid source for that rate **[UNVERIFIED]**, and young startups in most sectors fail at high rates, so AI may not be unusual. KNOWN / UNKNOWN: The failure modes above are inferred from the structure of the market. The real failure rate, and how it splits by layer, is unknown. COUNTER: Maybe AI startups fail for the usual reasons (no product-market fit, running out of cash, team problems), and "AI" adds little explanation beyond faster hype cycles. CONFIDENCE: Moderate on the mechanisms. The size of the failure rate can't be assessed yet without cohort data. WHAT CHANGES THIS: Cohort data showing AI survival rates in line with other software startups, or showing that infrastructure and vertical players survive far longer than wrappers.evals/2026-11-06/answers/H4_no-skill.md6.6 KB8c022cda6362upstream ↗
คำถามนี้ไม่มีคำตอบเดียวที่ถูกสำหรับทุกคน ขึ้นกับสถานการณ์ของคุณ แต่ผมช่วยวางกรอบให้ตัดสินใจได้ชัดขึ้นครับ ## ก่อนอื่น เช็ก 3 ข้อนี้ก่อน 1. **มีเงินสำรองฉุกเฉินแยกไว้แล้วหรือยัง?** ควรมีอย่างน้อย 6 เดือนของค่าใช้จ่าย ถ้ายังไม่มี ให้กันส่วนนี้ออกจาก 500,000 ก่อน ไม่ว่าจะเลือกทางไหน 2. **มีหนี้ดอกเบี้ยสูงไหม?** (บัตรเครดิต สินเชื่อส่วนบุคคล ดอกเบี้ย 16–25%) ถ้ามี ปิดหนี้ก่อนคุ้มกว่าการลงทุนแทบทุกแบบ 3. **รายได้มั่นคงแค่ไหน?** ถ้ารายได้ไม่แน่นอน การผูกตัวเองกับค่าผ่อน 20–30 ปีจะเสี่ยงกว่าที่คิด ## เปรียบเทียบสองทาง | | ดาวน์คอนโด | ลงหุ้น / กองทุน | |---|---|---| | **เหมาะเมื่อ** | ตั้งใจอยู่เองระยะยาว (7–10 ปีขึ้นไป) ในทำเลที่แน่ใจ | ยังไม่แน่ใจเรื่องที่อยู่ ต้องการความยืดหยุ่น | | **สภาพคล่อง** | ต่ำ ขายยาก ขายขาดทุนได้ | สูง ขายได้เกือบทันที | | **ภาระต่อเนื่อง** | ค่าผ่อน ค่าส่วนกลาง ค่าซ่อม ภาษี ประกัน | ไม่มีภาระบังคับ | | **ความเสี่ยงหลัก** | ราคาคอนโดมือสองในไทยหลายทำเลแทบไม่ขึ้น หรือลดลง, ซัพพลายล้น, ปล่อยเช่าไม่ได้ | ราคาผันผวน อาจติดลบ 20–40% ในช่วงตลาดแย่ | | **ผลตอบแทนที่คาดได้** | ถ้าอยู่เอง = ประหยัดค่าเช่า, ถ้าปล่อยเช่า yield สุทธิมักเหลือ 3–5% | กองทุนดัชนีโลกระยะยาวในอดีตเฉลี่ยราว 6–8% ต่อปี (ไม่รับประกัน) | ## หลักคิดที่ใช้ได้จริง - **"ซื้อเพื่ออยู่" กับ "ซื้อเพื่อลงทุน" ต่างกันมาก** ถ้าจะอยู่เองและค่าผ่อนใกล้เคียงค่าเช่า การดาวน์คอนโดมีเหตุผล แต่ถ้าซื้อเพื่อเก็งกำไรหรือปล่อยเช่า คอนโดในไทยช่วงนี้มักให้ผลตอบแทนไม่คุ้มความเสี่ยงและความยุ่งยาก - **ค่าผ่อนไม่ควรเกิน ~30–35% ของรายได้ต่อเดือน** รวมหนี้อื่นทั้งหมดแล้ว - **อย่าลงหุ้นด้วยเงินที่ต้องใช้ใน 3–5 ปี** ถ้ามีแผนซื้อบ้านเร็ว ๆ นี้ การเอาเงินดาวน์ไปลงหุ้นก่อนเสี่ยงว่าจะติดลบตอนต้องใช้ - **ถ้าเลือกหุ้น** สำหรับมือใหม่ กองทุนรวมดัชนี (ไทย + ต่างประเทศ) ทยอยลงทุนแบบ DCA มักดีกว่าเลือกหุ้นรายตัวเอง และลองดูสิทธิลดหย่อนภาษีอย่าง SSF / RMF / ThaiESG ด้วย ## ทางสายกลางที่หลายคนใช้ ไม่จำเป็นต้องเลือกแค่ทางเดียว เช่น - กันเงินฉุกเฉิน → ที่เหลือแบ่งลงกองทุนแบบทยอย แล้วเช่าอยู่ไปก่อนจนกว่าจะชัดว่าจะลงหลักปักฐานที่ไหน - หรือถ้าตั้งใจซื้อแน่ใน 1–2 ปี: เก็บเงินดาวน์ไว้ในที่ความเสี่ยงต่ำ (เงินฝากดอกเบี้ยสูง กองทุนตลาดเงิน) แล้วลงหุ้นเฉพาะส่วนที่เกิน ## ถ้าอยากให้ช่วยวิเคราะห์ให้ตรงขึ้น บอกผมได้เลยครับ - อายุ รายได้ต่อเดือน และความมั่นคงของงาน - ตอนนี้เช่าอยู่เดือนละเท่าไร - คอนโดที่สนใจราคาเท่าไร ทำเลไหน จะอยู่เองหรือปล่อยเช่า - มีหนี้หรือเงินสำรองอยู่แล้วเท่าไร - รับความผันผวนได้แค่ไหน ถ้าพอร์ตติดลบ 30% จะทนถือได้ไหม แล้วผมจะคำนวณเทียบ "ซื้อ vs เช่า + ลงทุน" ให้เป็นตัวเลขครับ *หมายเหตุ: นี่เป็นข้อมูลเพื่อประกอบการตัดสินใจ ไม่ใช่คำแนะนำการลงทุนเฉพาะบุคคล หากเป็นการตัดสินใจก้อนใหญ่ การปรึกษานักวางแผนการเงิน (CFP) ช่วยได้มาก*evals/2026-11-06/answers/H4_skill-5D.1.md15 KB90e8f1608124upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/answers/H4_skill-5E.md10 KB2876d18b6bd4upstream ↗
📍 **SITUATION** สิ่งที่คุณบอกมามีสองข้อ คือมีเงินเก็บ 500,000 บาท และกำลังเลือกระหว่างลงหุ้นกับดาวน์คอนโด สิ่งที่ยังไม่รู้คือ อายุ รายได้และความมั่นคงของงาน ค่าใช้จ่ายต่อเดือน หนี้ที่มีอยู่ เงินสำรองฉุกเฉิน คอนโดนี้จะอยู่เองหรือปล่อยเช่า และคุณจะต้องใช้เงินก้อนนี้เมื่อไร 📍 **FIRST PRINCIPLE BREAKDOWN** **Assumption:** หุ้นกับคอนโดเป็นการลงทุนเงิน 5 แสนเหมือนกัน **Challenge:** ไม่ใช่ การลงหุ้นเสี่ยงได้แค่เงิน 5 แสนที่ลงไป ส่วนการดาวน์คอนโดคือการซื้อสินทรัพย์ทั้งก้อนด้วยหนี้ที่ผ่อนกัน 20–30 ปี **Truth:** ความเสี่ยงของคอนโดอยู่ที่กระแสเงินสดรายเดือนตลอดหลายสิบปี ไม่ได้อยู่ที่เงินดาวน์ **Assumption:** ต้องเลือกใช้ทั้งก้อนกับทางใดทางหนึ่ง **Challenge:** ถ้าใช้หมดแล้วไม่มีเงินสำรองฉุกเฉินเหลือเลยล่ะ **Truth:** ก่อนจะเลือกอะไร ต้องกันเงินฉุกเฉินราว 6 เดือนของค่าใช้จ่ายออกมาก่อน (ถ้าจะมีค่างวดบ้าน ต้องรวมค่างวดไว้ด้วย) **Assumption:** คอนโดปลอดภัยกว่าเพราะ "ราคาไม่ลง" **Challenge:** คอนโดบางทำเลมีห้องเหลือขายเยอะ ขายต่อก็ยาก ส่วนหุ้นแม้ราคาจะแกว่งแรง แต่ขายได้ภายในวันเดียว **Truth:** สองอย่างนี้เสี่ยงคนละแบบ หุ้นเสี่ยงที่ราคาขึ้นลง คอนโดเสี่ยงที่สภาพคล่อง ภาระหนี้ และการใช้เงินกู้ซึ่งขยายทั้งกำไรและขาดทุน 📍 **COUNCIL** *(เฉพาะมุมที่ขัดกัน)* **Strategist:** ถ้าจะอยู่เองยาวๆ ค่างวดคอนโดก็เหมือนบังคับตัวเองให้ออม และได้ที่อยู่ที่เป็นของตัวเองแทนการจ่ายค่าเช่า **Skeptic:** ถ้าเอาดอกเบี้ย ค่าส่วนกลาง ค่าซ่อม และผลตอบแทนที่เงินดาวน์ควรจะได้ถ้าเอาไปลงทุนทางอื่นมารวมกัน หลายครั้งการเช่าถูกกว่าการซื้อ ต้องคำนวณเทียบกันจริง อย่าเชื่อตามความรู้สึก 📍 **OPTIONS** **A: ดาวน์คอนโด** เหมาะเมื่อจะอยู่เองจริงอย่างน้อย 5–7 ปี รายได้มั่นคง และค่างวดไม่เกินประมาณ 1/3 ของรายได้ ที่สำคัญคือหลังจ่ายเงินดาวน์ ค่าโอน ค่าส่วนกลาง และค่าเฟอร์นิเจอร์แล้ว ต้องยังมีเงินฉุกเฉินเหลือ แผนนี้พังได้จากการตกงาน ดอกเบี้ยลอยตัวที่ขึ้นหลังหมดช่วงโปรโมชัน หรือการต้องย้ายที่อยู่แล้วขายต่อได้ขาดทุน ถ้าซื้อเพื่อปล่อยเช่า ต้องคิดผลตอบแทนสุทธิหลังหักค่าส่วนกลาง ภาษี และช่วงที่ห้องว่าง แล้วเทียบกับดอกเบี้ยที่ต้องจ่าย **B: ลงหุ้น** ควรกระจายความเสี่ยง เช่น ลงผ่านกองทุนดัชนี ดีกว่าซื้อหุ้นรายตัวไม่กี่ตัว จะทยอยซื้อเป็นงวดใน 6–12 เดือน หรือลงก้อนเดียวก็ได้ แต่การทยอยซื้อช่วยลดโอกาสที่จะเข้าซื้อตอนราคาสูงที่สุด ลองถามตัวเองว่า ถ้าเงิน 5 แสนลดเหลือ 4 แสน (ติดลบ 20%) คุณจะถือต่อได้โดยไม่ตกใจขายไหม แผนนี้พังได้ถ้าคุณต้องใช้เงินในจังหวะที่ตลาดกำลังลง ถ้าขายเพราะตกใจ หรือถ้าลงเงินกระจุกอยู่ไม่กี่ตัว ต้นทุนที่ต้องคิดคือค่าธรรมเนียมกองทุนและภาษี **C: แบบผสม** กันเงินฉุกเฉินไว้ก่อน แล้วค่อยแบ่งส่วนที่เหลือ ถ้าตั้งใจจะซื้อที่อยู่ภายใน 1–3 ปี เงินดาวน์ส่วนนั้นควรเก็บในที่ที่ถอนได้ง่ายและราคาไม่แกว่ง ไม่ควรเอาไปไว้ในหุ้น ส่วนเงินที่ไม่ต้องใช้อย่างน้อย 5 ปีค่อยทยอยลงหุ้น 📍 **RECOMMENDATION** ข้อมูลตอนนี้ยังไม่พอจะเลือกให้ได้ แต่มีเงื่อนไขที่ช่วยตัดสินได้ชัดเจน - ยังไม่มีเงินฉุกเฉิน → ยังไม่ควรทำทั้งสองทาง ให้กันเงินฉุกเฉินก่อน - ยังไม่แน่ใจว่าอีก 5 ปีจะอยู่ที่ไหน → ไม่ควรดาวน์คอนโด - จะอยู่เองยาว และค่างวดรวมค่าส่วนกลางยังผ่อนได้สบาย → การดาวน์คอนโดสมเหตุสมผล - ไม่มีแผนซื้อที่อยู่ และถือหุ้นผ่านช่วงติดลบ 20% ได้ → ทยอยลงกองทุนที่กระจายความเสี่ยง **ก้าวแรก:** ลองคำนวณเทียบสองตัวเลข คือ "ค่าเช่าที่จ่ายอยู่ตอนนี้" กับ "ค่างวด + ดอกเบี้ย + ค่าส่วนกลาง ของคอนโดที่สนใจ" แล้วค่อยกลับมาทบทวนเมื่อได้ทำเลและราคาคอนโดที่ชัดเจน 📍 **EPISTEMIC CORE** **ASSUMPTION:** คำถามมองว่าสองทางนี้เป็นการลงทุนแบบเดียวกัน ซึ่งไม่จริง เพราะทางหนึ่งคือการลงทุน อีกทางคือการก่อหนี้ระยะยาว **KNOWN / UNKNOWN:** สิ่งที่รู้คือเงิน 5 แสนและทางเลือกสองทาง สิ่งที่ไม่รู้คือรายได้ หนี้ เงินฉุกเฉิน ระยะเวลาที่ต้องใช้เงิน และวัตถุประสงค์ของคอนโด **COUNTER:** ถ้าคุณมีวินัยไม่พอที่จะลงทุนสม่ำเสมอ การผ่อนคอนโดที่จ่ายไหวอาจสร้างความมั่งคั่งได้ดีกว่าหุ้นที่ซื้อๆ ขายๆ ตามอารมณ์ **CONFIDENCE:** ตอนนี้ยังประเมินไม่ได้ว่าทางไหนดีกว่า เพราะยังไม่รู้กระแสเงินสดและระยะเวลาของคุณ แต่มั่นใจสูงว่าควรกันเงินฉุกเฉินก่อน **WHAT CHANGES THIS:** ความมั่นคงของรายได้ แผนจะอยู่ที่ไหนในอีก 5 ปีข้างหน้า สัดส่วนค่างวดต่อรายได้ และความทนต่อการขาดทุนชั่วคราว *หากติดตั้ง `money-atlas-intelligence-os` ไว้ จะช่วยวิเคราะห์ภาวะตลาดหุ้นและดอกเบี้ยแบบล่าสุดเพิ่มให้ได้*evals/2026-11-06/answers/P1_no-skill.md6.8 KB487cf498e45bupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/answers/P1_skill-5C.1.md15 KB5dd6eac3fa75upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/answers/P1_skill-5D.1.md13 KB0447c31ee925upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/answers/P1_skill-5D.md7.8 KB9c7671c87d5fupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/answers/P1_skill-5E.md9.3 KBdcdda3ca0e26upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/answers/P2_no-skill.md5.1 KBf5933374f81bupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/answers/P2_skill-5C.1.md8.1 KBf6c8fbed0ff0upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/answers/P2_skill-5D.1.md8.8 KB75c108f78e55upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/answers/P2_skill-5D.md2.1 KB5cef0ab5582dupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/answers/P2_skill-5E.md5.0 KBcf3bbdca7259upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/answers/P3_no-skill.md1.9 KBa8a8e0bbbdeaupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/answers/P3_skill-5C.1.md5.8 KBc7ddc45c4dd3upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/answers/P3_skill-5D.1.md1.5 KB08a9ba4bd95cupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/answers/P3_skill-5D.md1.7 KB28964c4f4781upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/answers/P3_skill-5E.md1.9 KB7de94537f9f6upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/answers/P4_no-skill.md5.6 KBe9060c397361upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/answers/P4_skill-5C.1.md4.1 KB564111e06d26upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/answers/P4_skill-5D.1.md4.2 KB739a06d971d3upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/answers/P4_skill-5D.md3.9 KB09d1b5b45d45upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/answers/P4_skill-5E.md4.3 KB74a28ab94f16upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/grades/round1_grades.json12 KBfe1735f314aaupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/grades/round1_key.json210 B421834219b73upstream ↗
{ "P1": { "A": "no-skill", "B": "skill-5C.1" }, "P2": { "A": "no-skill", "B": "skill-5C.1" }, "P3": { "A": "no-skill", "B": "skill-5C.1" }, "P4": { "A": "no-skill", "B": "skill-5C.1" } }evals/2026-11-06/grades/round2_grades.json14 KB759c38edc6bdupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/grades/round2_key.json286 Bf20ad77975ecupstream ↗
{ "P1": { "X": "skill-5C.1", "Y": "skill-5D", "Z": "no-skill" }, "P2": { "X": "skill-5C.1", "Y": "skill-5D", "Z": "no-skill" }, "P3": { "X": "no-skill", "Y": "skill-5C.1", "Z": "skill-5D" }, "P4": { "X": "no-skill", "Y": "skill-5D", "Z": "skill-5C.1" } }evals/2026-11-06/grades/round3_final_grades.json19 KB789401db1de8upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/grades/round3_final_key.json370 B5abe3d8e93a3upstream ↗
{ "P1": { "W": "no-skill", "X": "skill-5D", "Y": "skill-5D.1", "Z": "skill-5C.1" }, "P2": { "W": "no-skill", "X": "skill-5C.1", "Y": "skill-5D.1", "Z": "skill-5D" }, "P3": { "W": "skill-5C.1", "X": "no-skill", "Y": "skill-5D.1", "Z": "skill-5D" }, "P4": { "W": "no-skill", "X": "skill-5C.1", "Y": "skill-5D", "Z": "skill-5D.1" } }evals/2026-11-06/grades/round3_final_summary.json1.7 KB4d90f68fd0ceupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/grades/round4_graderA.json24 KB357749ca90f8upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/grades/round4_graderB.json29 KBd7698a04ba53upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/grades/round4_key.json570 B58d37ddc88a5upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/grades/round4_summary.json1.8 KB0d3412befbe9upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/heldout_prompts.json826 B4a56b07279ddupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/prompts.json690 B08f569264c3eupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/rubric.md1.4 KBd9ebe8600488upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/rubric_round4.md2.0 KBc38bea0545eeupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/trigger/descriptions.json1.6 KB85739d5b94eeupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/trigger/result_5C.1.json983 B348236671917upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/trigger/result_5C.json965 B12eb12eb6d31upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
evals/2026-11-06/trigger/trigger_prompts.json1.0 KB04dc522927d6upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
EVOLUTION.md301 B68eb8c8340d5upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
EXECUTION_LAYER.md357 B5d3e670c6f58upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
FAILURE_SYSTEM.md110 B060a05b6b3ddupstream ↗
# FAILURE DETECTION Output invalid if: - No risk - No uncertainty - Too perfect Fix: → Add Skeptic Agentfirst_principle_codex.py13 KB6e2d90fdc1ebupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
genesis_core.py3.5 KB193c145d443aupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
genesis_core_vx.py3.3 KBab610d397c5dupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
genesis_full.py4.2 KB1ad67bc887c8upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
genesis_orchestrator.py1.3 KBdd00384ddd60upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
GENESIS_SKILL.md966 Bea136dec5b00upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
identity_core.py2.7 KB2d0c0d7d199fupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
LICENSE11 KBd64572eecdcdupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
llm/llm_client.py347 B47e57ebec5d7upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
main.py182 Bc6b3a75c200fupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
matador/matador_core.py601 B29786f3e525fupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
MEMORY.md266 B2036b00fdcc0upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
MODES.md382 B2b4fea29c2cdupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
multi_self.py992 Bccbc392da5a3upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
NOTICE3.0 KB15c1dc0a7b96upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
REFLECTION_LOG.md90 Bff1b3d697471upstream ↗
# SELF EVOLUTION LOG ## Format Date: Problem: What worked: What failed: What to update:requirements.txt109 Bd5ce38305db5upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
risk_model.py348 Bead765fc2497upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
run.py449 B75d8a1b5575fupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
run_genesis.py635 Ba67bb26c9169upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
shadow_genesis.py1.1 KBee964567087dupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
shadow_wrapper.py191 B9edc2b5ed141upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
tests/conftest.py409 Bfa3b9c4608cbupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
tests/test_decision_and_risk.py1.7 KBb703261dacc8upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
tests/test_first_principle_codex.py3.9 KB276ceb43a114upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
tests/test_plugin_package.py2.2 KB52f4a92598e7upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
tests/test_runtime.py4.3 KBc812367a220aupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
tests/test_skill_contract.py5.7 KB55496448eb55upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
tools/sync_plugin_skill.py717 B5626604f7c52upstream ↗
Contents are not inlined in the catalog. Open the upstream file.
tools/validate_skill.py3.4 KB96d3a1d6c2cdupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
Plain-text copy, no login: /skill-bundles/elmatadorz-genesis-mind-claudeskill-agent.md