skillZs
★ LIVE SKILL TAGS ★
>>> LIVE SKILLS INDEX <<<
* OPEN SOURCE *
NO LOGIN, NO TRACKING
※ REAL INSTALL DATA ※
← back to all skills
anentrypoint/gm54 installs

fifth-dimension-engine

Use after polaris-goal-compiler, or when a request is written as shoot + [problem]. Does not specify the problem or control drift.

How do I install this agent skill?

npx skills add https://github.com/anentrypoint/gm --skill fifth-dimension-engine
view source ↗

Is this agent skill safe to install?

  • Gen Agent Trust Hubpass

    The skill provides a structured reasoning framework for complex problem solving, defining a template for generating 'routes' with strategies and objections. It contains no code, network operations, or sensitive data access.

  • Socketpass

    No alerts

  • Snykpass

    Risk: LOW · No issues

What does this agent skill do?

Fifth-Dimension Engine

WFGY 5.0's core problem-solving tool. Lifts a target into a higher problem-coordinate, then returns a structured route that can be inspected, attacked, expanded, and tested. Route kinds: proof paths, strategy kernels, research structures, repair paths, positioning routes.

Before you decide, shoot first.

What This Is

The Fifth-Dimension Engine does not just answer. It transforms a target into a route.

InputEngine Action
TheoremProduces proof-route structure
Frontier problemProduces research kernel
Strange themeProduces mathematical skeleton
Life decisionProduces route map
Product ideaProduces positioning route
Engineering failureProduces repair path
Meme or absurd targetProduces hidden structure

The output is not a direct answer. It is a route: an inspectable, attackable, expandable structure you can verify, challenge, and refine.

When to Use

Use this skill when you have:

  • A well-specified problem (use Goal Compiler first if unclear)
  • A target worth spending time on (trivial problems don't need shooting)
  • An appetite for structured reasoning (prefer depth over speed)

Use especially for:

  • Theorem work (formal proofs, mathematical problems)
  • Strategic decisions (career, startup, major choices)
  • Research questions (turning ideas into research kernels)
  • Engineering failures (root cause analysis, repair paths)
  • Product/positioning work (audience, launch strategy)
  • Mixed-theme problems (combining unrelated ideas into research)

How to Use

Basic Command

shoot + [your problem]

The Engine Returns

A structured route containing:

  • Route: The core strategy or path forward
  • Structure: Decomposition into sub-problems
  • Candidate Lemmas: Supporting proofs, insights, or evidence
  • Objections: What could go wrong, counterarguments
  • Open Debt: What remains unresolved
  • Next Command: What to do next (for theorem work: a new Lean line; for other work: next investigative step)

Why This Matters

Instead of:

  • A flat answer (right or wrong, you can't inspect it)

You get:

  • A structure you can examine
  • Sub-claims you can verify independently
  • Attack surfaces (where to challenge it)
  • Expansion points (where to dig deeper)
  • Clear open questions (what's not yet resolved)

Interaction with Other Skills

With Polaris Goal Compiler

  • Goal Compiler specifies and atomizes the problem
  • Fifth-Dimension Engine produces the route
  • Goal Compiler's verification gates validate the engine's output

Integration: After Goal Compiler breaks work into atoms, use the engine on each atom that requires structured reasoning.

Workflow:

  1. Goal Compiler compiles the problem into task atoms
  2. For each atom, ask: "Do I need to shoot this, or is it routine?"
  3. If routine: execute directly
  4. If complex: shoot it with Fifth-Dimension Engine
  5. Use Goal Compiler's verification gate to check the output
  6. Move to next atom

With WFGY-Method (Drift Control)

  • Fifth-Dimension Engine produces structured reasoning
  • WFGY-Method keeps that reasoning aligned with the original goal

Integration: While the engine explores the route, WFGY-Method checks: "Are we still solving the original problem, or have we drifted into a different one?"

Use the engine for depth, WFGY-Method for direction.

Modes

Theorem and Formal Work

Shoot a theorem or formal problem; the engine returns a proof-route structure that can be checked against a formal verification standard.

Mixing Themes

Give the engine two unrelated themes and let it find the mathematical skeleton underneath them:

shoot + [theme 1] + [theme 2]

See references/research-kernel-extraction.md for how mixed themes become research kernels.

Everyday Problems

The same engine works on ordinary decisions, work problems, product questions, and engineering failures -- any well-specified target benefits from being shot into a route rather than answered directly.

Verification

The engine output is inspectable, which means verifiable. See references/route-inspection-guide.md for how to inspect, attack, and verify a route.

This is not: a black box. You can (and should) inspect, attack, and refine.

What This Is Not

This skill does not:

  • Specify the problem (that's Goal Compiler)
  • Control drift during execution (that's WFGY-Method)
  • Produce a final answer (it produces a route, which you then verify and decide on)
  • Guarantee the route is correct (inspection and verification are your job)
  • Claim every shoot becomes a final theorem (a shoot creates a structured route; final proof, empirical truth, or real-world correctness depends on verification, review, formalization, or testing)

References

See references/ directory for:

  • route-structure.md -- what a route is and how it is structured
  • research-kernel-extraction.md -- turning ideas into research kernels
  • route-inspection-guide.md -- how to verify and attack a route
  • skills/polaris-protocol/SKILL.md -- the Polaris Protocol tree root and state machine

Finish the work

  • Finishing the requested work is the goal of every run of this skill. A run that stops with work left undone is incomplete.
  • When an issue blocks a step (a failing check, a fault in a tool or service, a missing input, a network or environment fault), fix it in the same run: retry on a bounded or resumable route, use an alternate route to the same result, repair the fault where it originates, then continue the remaining work.
  • Stop only when the requested work is complete, or when a step is still blocked after every route has been tried. Then report the blocked step, the routes tried, and the evidence for each.

Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.

<a href="https://skillzs.dev/skills/anentrypoint/gm/fifth-dimension-engine">View fifth-dimension-engine on skillZs</a>