Skills + Goals Trainer

Your skills.
Your goals.
Your rules.

Turn AI instructions into Standard Operating Procedures your AI can actually execute. Author once — Graphnosis personalises against your memory, links steps as a typed graph, and hands any MCP-connected AI a deterministic plan to run.

Download Graphnosis v1.12.0 Browse 100+ free .gsk packs →

📋 SOPs, not blobs 🎯 8-category goals 🔗 Cross-skill orchestration 🧠 Retrains against your memory

The shift

A skill is graph state, not text.

Most AI tools store instructions as flat blobs — a system prompt, a CLAUDE.md, a .cursorrules file. Graphnosis compiles them into Standard Operating Procedures — steps in order, loops and branches detected, sub-skill calls wired, named inputs and outputs declared. The AI doesn’t read prose — it walks a typed graph.

Everywhere else

A blob of text

✗No structure — just paragraphs
✗Recall results appended at the end as a wall of context
✗No declared inputs, outputs, or failure handlers
✗One skill can’t safely invoke another
✗Retrain = lose your manual edits

In Graphnosis

A Standard Operating Procedure

✓Each step is a typed graph node with sequence, loop, and branch edges
✓Recalled memory is surgically placed at the step where it makes the SOP read coherently
✓Declared Requires / Produces variables, plus failure handlers
✓Skills call other skills via @skill name(args) -> $capture
✓Snapshot-based history — every retrain is reversible

The result: an AI doesn’t guess what your skill meant — it reads the structure and walks it. Recall’d memories arrive at the right step. Failures route to the recovery skill you declared. The handoff is deterministic.

Goals — built in, not bolted on

Eight goal categories per skill.
All structured. All optional.

Every skill carries a goals block. The AI reads it before invoking the skill, during execution, and after — so it knows when to fire, what it needs, what it should produce, and where to route failure.

Success

What a successful outcome looks like for this skill.

Success:

Out of scope

What this skill should not attempt — bounds the AI’s authority.

Out of scope:

On completion

What tangible output or behaviour is expected when the skill completes.

On completion:

Trigger

When the AI should autonomously invoke this skill — the gate for self-routing.

Trigger:

Prerequisites

What must be true before step 1 can run. Checked before any work happens.

Prerequisites:

On failure

Recovery if execution fails mid-procedure. May name a recovery skill to invoke.

On failure:

Requires

Named inputs this skill expects from its caller or context. $camelCase.

Requires:

Produces

Named outputs this skill makes available to callers. Captured by the next step.

Produces:

AI clients receive a structured SkillExecutionPlan JSON containing every goal value. They confirm prerequisites before they start, capture Produces outputs into named variables, and route exceptions through declared failure handlers.

Composition

Skills call other skills.

One orchestrator skill, several sub-skills, named arguments, captured return values, a recovery skill on failure. Every link is a graph edge the AI can walk — not text it has to parse.

safe-deploy.gsk · orchestrator SOP

[ANCHOR] Deploy the named branch to production safely.
Each step gates the next; on any failure, hand off to
the rollback skill.

@skill: validate-environment(branch=$branch) -> $envOk

If $envOk is false, abort and surface the
validation report.

@skill: run-migrations(branch=$branch) -> $migrationReport

@skill: smoke-tests(branch=$branch) -> $smokeReport

If $smokeReport.failed > 0, the deploy is not
complete — invoke the rollback path.

Goals

Success: the branch is live, migrations are applied, smoke tests are green
Out of scope: modifying production data, bypassing CI, deploying without a code review
Prerequisites: CI on the branch is green, $branch variable is set
On failure: invoke @skill: rollback-deployment with the failure context
Requires: $branch · Produces: $envOk, $migrationReport, $smokeReport

What an AI does with this

1.Calls walk_skill_structured on Safe Deploy.
2.Sees requires: ['$branch'] and confirms $branch=main with the user.
3.Sees prerequisites and asks the user to confirm CI is green.
4.Walks steps in order. Invokes validate-environment, captures $envOk.
5.If $envOk is false, surfaces it and stops.
6.Otherwise continues to migrations, smoke tests, capturing each return.
7.On exception → reaches for failureHandlers[0].targetTitle = rollback-deployment.

Sub-skill calls work in English, Romanian, Spanish, French, German, Italian, and Portuguese out of the box, plus a language-neutral explicit syntax (@loop: N, @branch: N) that detection always tries first.

Tools your AI uses

Two contracts — one for humans, one for execution.

Every trained skill is reachable from any MCP-connected AI client through one of two tools. The narrative tool is for explaining; the structured tool is for executing.

MCP tool walk_skill

Narrative walkthrough

Returns the skill as human-readable text with CONSTRAINTS and PROCEDURE sections. Loop-back steps, conditional branches, and sub-skill invocations are annotated inline.

Use when explaining the skill to a user, or guiding them through it conversationally one step at a time.


Step 1: Configure the environment...
  → Context: prior CI fixture for this branch

Step 2: Run the validation suite...

Step 3: INVOKES SKILL: run-migrations

Step 4: Review logs — BRANCHES to step 6 if failed

Step 5: LOOPS BACK to step 2

MCP tool walk_skill_structured

Execution plan (JSON)

Returns a SkillExecutionPlan with requires, produces, ordered steps with calls (target sub-skill + args + captureAs), plus failureHandlers.

Use when the AI is actually going to execute the skill — walk steps in order, invoke sub-skills with named args, capture return values, route exceptions through declared failure handlers.

{
  "skill": { "title": "Safe Deploy", ... },
  "requires": ["$branch"],
  "produces": ["$envOk", "$migrationReport"],
  "constraints": {
    "prerequisites": "CI on the branch is green",
    "onFailure": "rollback-deployment"
  },
  "steps": [
    { "index": 1, "text": "...",
      "calls": {
        "targetTitle": "validate-environment",
        "args": ["$branch"],
        "captureAs": "$envOk"
      }
    }, ...
  ]
}

Retraining

One source per skill, ever.

Retrain a skill against fresh memory — goals, recipes, and structure are rewritten in place. The prior version is saved to an encrypted side-table so you can roll back any retrain that drifted.

In-place rewrite

The skill’s graph nodes are mutated in place. Cross-source edges referencing this skill stay intact. No orphan title nodes accumulate in your engram from old trains.

Encrypted snapshots

Before every retrain, the prior state is dumped to .json.enc under skill-snapshots/, sealed with the same data key that protects your .gai engrams.

Reversible rollback

rollback_skill restores any prior version. The current state is re-snapshotted first — so even the rollback itself is reversible.

The trainer also self-tunes recall breadth — on each train, the cited-vs-fetched ratio nudges the next retrain’s recall window wider or tighter. You don’t tune it — it learns.

See your SOPs

The 3D Engram.
Your skills as a living graph.

A force-directed 3D view of your cortex — nodes drift instead of snapping, edges colour by category, GNN predictions float in as a dashed overlay you can toggle. Watch your skills settle into clusters; drag a node and pin it.

3D Engram view showing skill SOPs as colored clusters with sequence, branch, and call edges

Seven edge categories

Reasoning · Structure · Social · Temporal · Semantic · Identity · Predicted — the legend toggles each independently.

Explore your AI hippocampus

Graphnosis is modelled on the hippocampus — the brain region that binds disparate memories into something coherent. This view is its digital twin. Drag any node to study its neighbourhood; the physics engine pins it where you dropped it. Watch dense clusters loosen, isolated nodes drift to the rim, and the shape of your AI’s memory emerge. The first time you flatten a tangled SOP chain by hand and see why two skills were quietly related, you’ll know what your AI has actually been seeing.

Optional neural network overlay

A local graph neural network proposes edges your explicit notes never made — rendered as a dashed lime layer that you toggle on or off. The deterministic graph below stays untouched; the network just shows you what it thinks is missing.

Source-coloured nodes

Each node carries its source colour — the .gsk pack it came from, the document it was ingested from, the skill it’s part of. Cross-source clusters jump out instantly.

Filter, hover, hide

Hover a legend category to fade everything else. Click to lock the filter. Hide an entire source while you work on another. The atlas is your workshop, not a museum.

Click-select inspector

Click any node — the inspector opens with its content, type, confidence, source provenance, and every incoming/outgoing edge with evidence labels. The atlas IS the inspector.

Built on a force-directed simulator with cursor-aware zoom and a left-aligned camera that compensates for the legend strip — so your fit-view always frames the cortex, not the chrome.

Portable, verifiable, free

One file. Every skill. Signed.

A .gsk file is the wire format for Graphnosis skills — AES-256-GCM encrypted JSON wrapping the skill text, recall recipes, structured goals, and an optional GRAPHNOSIS.md companion. Ed25519 signature is the real integrity gate: tampered files hard-fail import.

100+ free packs

Role-matched .gsk kits for engineering, healthcare, legal, finance, defense, robotics, education — every kit free.

Browse the library →

Ed25519-verified

Every official pack carries a signature. The import UI shows a ✓ Verified badge or ⚠ Community on unsigned packs. Tampered files reject before any byte reaches your cortex.

3 bundled demos

On first cortex unlock, the App auto-creates a Skill Demos engram and imports three signed teaching skills: Use Graphnosis well, Save memories that last, and Stay safe with sensitive memories.

Six export formats

claude-md · cursorrules · system-prompt · openai · raw · gsk — export to the format your tool expects.

Privacy by design

Export serialises only the structural payload — skill text, recipes, graphnosisMd, goals. It never sees your personal memory engrams. The direction of personalisation travels; the memories that caused it stay local.

Skill vitality

Know when a skill is going stale.

Every trained skill carries a vitality score — 0 to 100, measured by how many of the memories that originally shaped it have since been forgotten, edited, or superseded.

80–100Fresh — the influential context still holds.
60–79Healthy — minor drift, no action needed.
40–59Aging — consider retraining.
0–39Stale — call train_skill.

The score is exposed through the skill_vitality MCP tool so AI clients can prompt the user to retrain stale skills before acting on them.

Example library

Code review SOP ↻ 94

Safe deploy ↻ 72

Customer onboarding ↻ 51

Quarterly close ↻ 28

From file to walked SOP

Four steps. Zero cloud hops.

Paste your skill

A CLAUDE.md, a system prompt, a .cursorrules file — or download one of 100+ free .gsk packs from the Job Memory Kits library.

Set goals

Declare any of the eight goal categories. The trainer runs goal-aligned recall — per-category queries that surface the memories most relevant to each dimension of your skill.

Train

The trainer interleaves your memories at the exact step where they fit. With Ollama on, you watch the rewrite stream in live with (from memory: ...) attribution on every changed line.

Walk & ship

Export to your tool’s format, or leave the skill in Graphnosis and let any MCP-connected AI walk it via walk_skill_structured.

Anchored lines

Any line you prefix with [ANCHOR] is preserved exactly across every retrain — no paraphrase, no rewrite. Use anchors for the parts of your SOP that must never drift.

Graphnosis Autonomous Praxis

Your AI doesn’t guess what your skill meant.
It walks the graph you authored.

Every skill is signed, structured, and executable. Every retrain stays one source. Every exception routes to the recovery skill you declared. Every byte that shaped the personalisation stays on your machine.

That’s the praxis: AI that knows what to do, why it’s doing it, and what to do when it goes wrong — because you told it once, in a form it can execute.

Skills + Goals Trainer ships with Graphnosis.

Download Graphnosis, unlock your cortex, and open the Skills tab. The free tier gives you author / browse / walk / retrain against your memory with a Personal Context block. Pro adds the streaming LLM rewrite with per-line memory attribution.

Download Graphnosis v1.12.0 Browse 100+ free packs

Free forever · 100+ signed .gsk packs · macOS 13+ · Windows 10+

Your skills. Your goals. Your rules.