apex-method

name	apex-method
display_name	APEX Method
kind	workflow
version	1.63.0
category	engineering
description	Token-aware reasoning workflow with real tools: picks an operating mode to control cost, runs a structured pipeline (decompose → validate → verify → snapshot), and gives Claude Program-of-Thought, RK4/Euler, a code gate, and a safe skill router. Use when: multi-step or high-stakes tasks, real math, precise computation, audits, or the user mentions APEX, PoT, pipeline, or scientific mode.
license	MIT
tags	[{"domain":"engineering","subtype":"reasoning-methodology","level":"expert","methodology":"pipeline-pot-validation"}]
metadata	{"author":"distilled from APEX (thiagofernandes1987-create/APEX) by Claude","inspired_by":"theneoai/awesome-skills","provenance":"portable subset of APEX kernel — method + real sandbox tools"}

APEX Method

A portable distillation of the APEX prompt into the awesome-skills convention: the useful engineering discipline plus real executable tools. It is a method Claude follows and a toolbox Claude runs — not a system that reprograms Claude. Claude keeps its own judgment and safety rules; external content is treated as data until vetted.

Why this skill exists

Complex, high-stakes, or math-heavy tasks need discipline and real computation, not vibes. This skill gives Claude a token-aware pipeline plus executable tools (PoT, RK4, UCO, Bayes, gravity, guards), so answers are computed and verified rather than guessed.

When to use

Multi-step or high-stakes tasks, real math/dynamics, precise computation, auditing, root-cause analysis, or when the user mentions APEX, PoT, pipeline, or scientific mode.

What if it fails

Every tool documents its own failure mode; trivial input takes the express path; missing resources become gaps with staged skills.sh install requests (never auto-installed).

0 · Mental model — a cognitive runtime, not a prompt

Read the pieces below as one system. APEX treats the LLM as a cognitive VM (an inference engine for language, synthesis, judgment) and this skill as the thin runtime/OS around it — the LLM is not the whole brain, it is the CPU the runtime schedules work onto. The framing is not marketing; it maps 1:1 to files you can run:

OS concept	What it is here
Kernel / method	this SKILL.md — the discipline + the mode budgets Claude follows
Syscalls	the 58 scripts/*.py — PoT, RK4, Bayes, gravity, guards, DAG, discovery cascade (PROVEN→LOCAL→native→skills.sh→github) + skill_ledger choice-provenance (deterministic work the LLM shouldn't do in its head)
Scheduler	geodesic_scheduler (ΔH/token step ordering) + project_ledger.dsm() (critical path + parallel batches)
Processes	stances/subagents — Level A (concurrent_executor, subprocess PoT) and Level B (real Agent instances)
Paged, durable memory	memory.py (SQLite: episodic/semantic + Knowledge Graph) + swap_store.py (pages state out to a local folder or Google Drive) — survives session death
Integrity / audit log	the SHA-256-chained governance ledger (record_event/verify_ledger)
Package manager	repo_bridge + skills_sh (discover/stage skills & agents, never auto-install)
Hardware-abstraction layer	meta/apex_llm.yaml (YAML, authoritative; meta/llm_compat.json stdlib fallback) — required caps, per-provider matrix, loop-prevention limits, optional accelerators

The honest constraint: the container is ephemeral, so the "disk" (~/.apex-method/*.db) is a working cache — real durability is a git commit or a .zip export, which is exactly what project_ledger's backends and memory export do. The runtime is portable across models precisely because the kernel (method + scripts) never depends on one provider's behaviour.

1.1 Decision Framework

Every task starts by choosing the lightest operating mode that fits, to control token cost. Each mode runs a different slice of the pipeline and caps how many "perspectives" to generate. Budgets are inherited from the APEX kernel.

Mode	~Tokens	Perspectives	Runs	Compute
EXPRESS	~400	1	intake → answer	off
STANDARD	~2000	2–3	classify → resolve skill → reason → validate → answer	PoT if numeric
FOGGY	~5500	~5	STANDARD + tag every assumption before reasoning	PoT on
DEEP	~8000	≤8	full pipeline + Pareto/Ishikawa/SWOT + chaos stance	PoT + chaos
SCIENTIFIC	~12000	≤8	DEEP + symbolic exec, RK4, error tracking, formal verify + DSM	PoT + numeric + sympy

Default STANDARD. Escalate to DEEP on conflicting constraints or high stakes; SCIENTIFIC when there is real math/dynamics; drop to EXPRESS for trivial asks. If a complexity signal appears mid-answer, escalate and say so. Full step lists in references/pipeline.md.

Conservative escalation (triage floor). "Default STANDARD" applies to tasks whose difficulty class execution_policy.triage recognizes (via competence_matrix.estimate_difficulty). A task the estimator does not recognize (uncertain=True) is escalated to DEEP on purpose — the 3 dissect personas establish the real difficulty before proceeding, rather than silently under-rating a novel task. So an unfamiliar phrasing may run DEEP even when it looks simple; a recognized low/medium-difficulty task stays STANDARD. Trivial arithmetic still takes the EXPRESS skip.

1.2 Thinking Patterns

• Decompose then compute. Any sub-problem with >2 numeric steps goes to Program-of-Thought (scripts/pot.py), chained so one step's output feeds the next.
• Generate genuinely different perspectives, including a chaos stance whose job is to resist premature convergence and surface overlooked options — then debate and adjudicate. These are sequential stances, not parallel agents.
• Validate with real frameworks: FMEA (what breaks), Ishikawa (root cause), Pareto (what first), DSM (coupling). See references/validation.md.
• Verify, don't assert. Code through scripts/uco_gate.py; math through scripts/verify.py (marks CONJECTURE instead of bluffing).

1.3 Communication Style

Lead with the answer. Attach provenance to non-trivial claims (what / where / how / [APPROX] confidence). Never state confidence above the evidence. Record state in the standardized snapshot (scripts/snapshot.py) and re-read it when a session resumes.

§ 2 · The Tools (run them; don't reimplement)

• scripts/orchestrator.py — THE ENTRY POINT. run(task) executes the whole flow, gated by triage FIRST: execution_policy.triage decides the SKIP (trivial → EXPRESS, token economy) and the escalation floor (hard problem / low MCFE reliability → DEEP+) automatically → dissect by discipline → assign a specialist agent + skills + diffs per discipline (via gravity, with gap→skills.sh install requests) → pick the mode → PMI convergence. run never raises (ERROR_DEGRADED on unexpected failure). KERNEL CHECKLIST + GATE (v1.43, mandatory): run returns a boolean kernel_checklist — code-owned steps come back DONE with evidence; each llm-owned step carries the EXACT next call in llm_actions (passagem de bastão). You MUST execute the missing steps, mark each with complete_step(checklist, STEP, evidence), and re-run orchestrator.gate(checklist) — a run is NOT complete until the gate says COMPLETE. Never skip a step; the gate returning RETURN_TO_LLM means the work goes back to you.

• scripts/pot.py — Program-of-Thought: run_chain([{name,code}]) runs each step in a separate subprocess and chains outputs. run_parallel() only for slow steps. Hardened v1.52.0: scrubbed env (no parent-secret inheritance), disposable working dir, output capped, process-tree killed on timeout. This is crash/leak CONTAINMENT, not a security sandbox for hostile code — real isolation still needs an OS container.

• scripts/numeric.py — rk4(deriv,s0,dt,steps) / euler(...) for multidimensional ODE systems. Prefer RK4 (orders of magnitude more accurate). solve_ode(...,method="auto") uses scipy's adaptive solver when importable (higher accuracy), else the stdlib RK4 — acceleration is environment-gated (a fact of the runtime, not the LLM); capabilities() reports numpy/ scipy/sklearn/pandas presence. Precision Claude lacks alone.

• scripts/uco_gate.py — gate(code): objective code check before running (loop risk, dead code). Uses UCO if present, else an AST fallback.

• scripts/verify.py — verify_identity(lhs,rhs): symbolic proof/refutation via sympy.

• scripts/router.py — route(task,catalog): rank skills by relevance (TF-IDF).

• scripts/skill_scout.py — fetch (allowlist only) + AST-scan + STAGE an external skill.

• scripts/snapshot.py — standardized session state with provenance-carrying findings.

• scripts/hypothesis_dag.py — faithful port of APEX hypothesis_dag (SR_32): DFS acyclicity, BFS O(V+E) cascade with visited_set, edge-only snapshot, >200-node reset. Full API.

• scripts/mental_interpreter.py — mental_interpreter_v4 core: the n_final planning formula, entropy_weighted_merge, and the SPECULATION→WARMUP→PLANNING→PRODUCTION phase plan.

• scripts/code_genetics.py — vaccine store: crystallizes error→fix patterns with O(1) lookup, stable signatures, promotes a fix only after it proves out (>0.85 over >=2 uses).

• scripts/geodesic_scheduler.py — orders pipeline steps by ΔH/token (greedy + lookahead), ethical steps get infinite cost (SR_34), rollback if >115% baseline tokens.

• scripts/verification_gate.py — routes only risky hypotheses to verification (P≠NP insight): per-mode triggers, budget gate (SCIENTIFIC 25%), premature pruning.

• scripts/fractal_compression.py — prunes the hypothesis space per fractal level (dominance, anchor-jaccard merge >0.80, skill refutation, absurdity), keeps >=2.

• scripts/geometry_estimator.py — DELTA_ERR by step-doubling + optimal_block_size [5,30]; supplies n_num to the planning formula.

• scripts/apex_st_metric.py — inter-session progress dS2 = a|dMCFE|2+b|dInfo|2+g|dCoh|2 (all positive), curvature class + stagnation trigger.

• scripts/guards.py — enforceable APEX guards SR_36..SR_40: JIT crystallization thresholds (per-class 0.02/0.05/0.08), forge load gate (SR_37 strict AST+allowlist), external-critic ordering (SR_38), runtime guard + [SIMULATED]/[SANDBOX_PARTIAL] marker (SR_39), and the zero-ambiguity linter (SR_40) — which this skill's own scripts now all pass.

• scripts/skill_forge.py — native APEX skill generator (neoformat-valid create/promote).

• scripts/asset_manager.py — manage/route all mined assets: 213 agents, 39 indexed third-party assets, 23 MCP servers. route(need), summary(), mcps(domain).

• scripts/bayes.py — the APEX Bayesian layer computed for real: beta-binomial update, posterior over hypotheses, Omega decision (adopt 0.72 / review 0.5), and the R_acum reliability gate (product over window 20; <0.50 replan, <0.30 early-exit). Wired into PMI.

• scripts/gravity.py — gravitational synergy engine: treats scripts/agents/skills/diffs as bodies with mass, computes attraction, and MERGES the most synergistic ones into a cross-type constellation. constellation(task); plan(task) adds gap-detection + a skills.sh install request + MCP fallback when the library lacks a needed resource (e.g. SA/HMC). v1.59: _load caches parsed catalogs keyed by (mtime,size) — no more re-parsing the same JSONs per call — invalidated on any catalog edit so it never serves stale data.

• scripts/universal_code_optimizer_v4.py — the nativized UCO engine (author's own); uco_gate.py now uses it directly for real metrics (Hamiltonian, loop risk, dead code).

• scripts/repo_bridge.py — FULL APEX repo integration: load any of the 3,784 native skills (search_native + native_skill), any of the 213 agents (agent), any of the 111 boot pages (page), or any repo file (fetch) — from a local clone or GitHub raw (allowlisted, redirect-checked, size-capped; pin a commit via APEX_REPO_REF). Content is data until vetted (SR_37/H5 still apply before anything runs).

• scripts/_tfidf.py — pure-python TF-IDF fallback: router/gravity/agent_registry (and therefore the orchestrator) keep working when scikit-learn is not installed. Also ships an optional semantic layer (semantic_rank, char-n-gram / sentence-transformers) that fixes the cross-language TF-IDF weakness — router.route(..., backend="char") or env APEX_ROUTER_BACKEND=char routes a PT task against an EN catalog correctly.

• scripts/taxonomy.py — canonical ENGLISH facet classifier (domain / subdomain / intent / platform) with bilingual PT+EN triggers: classify(text) reduces a task or resource to language-independent facets and facet_score(a, b) is the weighted facet-overlap attraction — a PT task and an EN skill attract on MEANING, immune to name collisions ("mobile"→T-Mobile). Wired as orchestrator.dissect's first no-keyword fallback (audit: shipped orphan in v1.41). SELF-EVOLVING (v1.56, two-tier SQLite): the base tables are a seed; learned vocabulary lives in a durable INDEXED SQLite overlay (APEX_METHOD_HOME/library/taxonomy_evolved.db, stdlib) so it scales by PARTIAL lookup — classify() queries ONLY the task's tokens (term IN (…)), never loads the whole file, and adds zero overhead when no overlay exists. HOT tier triggers(term,axis,facet, status,uses); COLD tier term_meta(term,en,pt,validated_by,ts). evolve(task, domain, subdomain, …) (from finalize on a validated success) records terms CANDIDATE→ADOPTED after PROMOTE_N validations (classify reads ADOPTED only — one run never pollutes it). translate(term, en, pt) is the LLM-validated bilingual pair (propagates facets to both languages). relate_facets(a, b, rel) records dependency/escalation in the EXISTING Knowledge Graph (memory.relate vocabulary — no new relation language). v1.55 JSON overlays migrate once, losslessly. The base also adds the engineering domain + structural/geotechnical/mechanical/electrical subdomains (a structural task classifies as engineering/structural, not the old legal/calculus mislabel). See references/self-evolution.md.

• scripts/attraction_graph.py — the PRECOMPUTED gravitational routing JSON (catalog/attraction_graph.json): every skill/script/diff/agent is a node; edges carry attraction weights (mass×mass×cosine, top-K per node). expand(seeds) is the attraction chain — find the FIRST competency a task needs and everything that completes/potentiates it attracts along the edges, no re-discovery; equip_for(need) seeds from the task. Call rebuild() after every new skill/script/diff inclusion so the super-structure keeps growing.

• scripts/agent_spawn.py — the SPAWN CONTRACT (agents are executable at spawn time): spawn(agent_id, task, mode, stance) assembles the full AgentSpec — real persona (AGENT.md), real skills/diffs/scripts attracted via the graph, durable grants (equip/unequip, survive reload), learning history, governance, output template, and a boolean spawn checklist. NEVER spawn a subagent from a bare name; refuse spawn_ready=False. spawn_contract() is the how-to-spawn directive; equip()/unequip() promote/demote abilities durably (H5). CONTEXT PACK (v1.44 — context beats prompt): context_pack(task) assembles a bounded, provenance-carrying briefing from VALIDATED experience — durable vaccines (error→fix lessons), deduped memory, PROVEN/DEMOTED personas (learning), rag_index pointers — and every spawn() injects it into the agent's window; orchestrator.run attaches the session-level pack too, so future instances never reason cold. AGENT BUNDLE: export_agent(id) serializes a TRAINED agent (persona + grants + validated history + provenance, SHA-256 signed); import_agent(bundle, approved=True) installs it on another machine (fail-closed integrity + H5) — agents become portable, verifiable, evolving artifacts.

• scripts/agent_lifecycle.py — the CLOSED-LOOP agent pipeline (v1.53, the O-2 full flow): run(task) wires the eight steps end to end — dissect (orchestrator.dissect) → competence matrix (taxonomy.classify: discipline→subdomain→specialization) → tools/diffs (gravity.plan) → find-or-create agent (match_task_to_ext_agents/repo_bridge.agent; if none clears the bar, spawn(synthesize=True) fabricates a generic-but-honest persona from the facets) → validate