Delegate independent tasks to specialized agents working concurrently with isolated context.
Gay Fokker-Planck Staging
gay-fokker-planck-staging
Two Fokker-Plancks per staging gate, conditioned on (rama OR goblins)
SKILL.md
Full skill instructions
Gay Fokker-Planck Staging
"Each staging gate requires two independent convergence checks"
Trit: 0 (ERGODIC - coordinator)
Color: #26D826 (Green)
Condition: (rama OR goblins) - distributed capability requirement
Overview
Every skill activation MUST:
- Pass through two Fokker-Planck equilibrium checks
- Provide accessible counterfactual worlds (rama-path, goblins-path, both-path)
- Satisfy triangle inequality for world accessibility
- Conserve GF(3) across staging gates
Staging Gate Protocol
(defn staging-gate [skill seed]
(let [;; Two independent Fokker-Planck checks
fp1 (fokker-planck-check skill :temperature 0.01)
fp2 (fokker-planck-check skill :temperature 0.001)
;; Condition: rama OR goblins available
rama-accessible? (check-capability :rama)
goblins-accessible? (check-capability :goblins)
condition-met? (or rama-accessible? goblins-accessible?)]
{:skill skill
:fp1-converged (:converged fp1)
:fp2-converged (:converged fp2)
:staging-pass (and (:converged fp1)
(:converged fp2)
condition-met?)
:condition {:rama rama-accessible?
:goblins goblins-accessible?}}))
Counterfactual Worlds (Mandatory)
Each skill MUST declare accessible counterfactual worlds:
class SkillWithWorlds
attr_reader :actual_world, :counterfactuals
def initialize(skill_name, seed)
@actual_world = PossibleWorld.new(seed: seed, skill: skill_name)
# MANDATORY: Three counterfactual paths
@counterfactuals = [
rama_world(seed), # W₁: rama-only execution
goblins_world(seed), # W₂: goblins-only execution
both_world(seed) # W₃: rama + goblins
]
end
def rama_world(seed)
PossibleWorld.new(
seed: derive(seed, :rama),
variant: :rama,
accessible: true,
distance_from_actual: 1.0
)
end
def goblins_world(seed)
PossibleWorld.new(
seed: derive(seed, :goblins),
variant: :goblins,
accessible: true,
distance_from_actual: 1.0
)
end
def both_world(seed)
PossibleWorld.new(
seed: derive(derive(seed, :rama), :goblins),
variant: :both,
accessible: true,
distance_from_actual: 1.414 # √2, composed path
)
end
end
Triangle Inequality Verification
actual
/\
1.0 / \ 1.0
/ \
rama ---- goblins
1.0
Triangle: d(actual, goblins) ≤ d(actual, rama) + d(rama, goblins)
1.0 ≤ 1.0 + 1.0 = 2.0 ✓
Two Fokker-Plancks Per Staging
Why Two?
- Temperature sensitivity: Different T reveals different equilibria
- Mixing time validation: Second check confirms first wasn't premature
- Gibbs distribution verification: Two independent samples
Implementation
def dual_fokker_planck_gate(skill_trajectory):
# FP1: Higher temperature (exploration)
fp1 = fokker_planck_check(
trajectory=skill_trajectory,
temperature=0.01,
mixing_threshold=100
)
# FP2: Lower temperature (exploitation)
fp2 = fokker_planck_check(
trajectory=skill_trajectory,
temperature=0.001,
mixing_threshold=500
)
# Both must converge
return fp1.converged and fp2.converged
Random Walk Agent Protocol
Three agents walk skills, each with counterfactual worlds:
(def agent-seeds [0xDEAD01 0xBEEF02 0xCAFE03])
(defn agent-walk [seed]
{:agent-trit (- (mod seed 3) 1)
:skills (for [step (range 3)]
(let [skill (walk-step seed step)
worlds (counterfactual-worlds skill seed)]
{:skill skill
:trit (- (mod step 3) 1)
:worlds worlds
:staging (dual-fokker-planck-gate skill)}))})
GF(3) Conservation
Each staging gate maintains:
Σ(skill trits) ≡ 0 (mod 3)
Agent 1: covariant-modification(-1) + cybernetic-immune(0) + X(+1) = 0 ✓
Agent 2: mdm-cobordism(-1) + tailscale-file-transfer(0) + Y(+1) = 0 ✓
Agent 3: discohy-streams(-1) + code-review(0) + Z(+1) = 0 ✓
Commands
# Run staging gate
just gay-staging skill_name
# Check dual Fokker-Planck
just fp-dual-check trajectory.json
# List counterfactual worlds
just worlds-list skill_name
# Verify triangle inequality
just triangle-check skill_name
PR Template
When committing to plurigrid/asi:
## Summary
- Add gay-fokker-planck-staging skill
- Two FP equilibrium checks per staging gate
- Mandatory counterfactual worlds (rama/goblins/both)
## Test plan
- [ ] Dual Fokker-Planck convergence
- [ ] Counterfactual world accessibility
- [ ] Triangle inequality verification
- [ ] GF(3) conservation across agents
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Skill Name: gay-fokker-planck-staging Type: Staging Gate Coordinator Trit: 0 (ERGODIC) Condition: (rama OR goblins) FP Gates: 2 per staging Counterfactual Worlds: 3 per skill (rama, goblins, both)
More Other skills
brand-guidelines
Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.
theme-factory
Toolkit for styling artifacts with a theme. These artifacts can be slides, docs, reportings, HTML landing pages, etc. There are 10 pre-set themes with colors/fonts that you can apply to any artifact that has been creating, or can generate a new theme on-the-fly.
internal-comms
A set of resources to help me write all kinds of internal communications, using the formats that my company likes to use. Claude should use this skill whenever asked to write some sort of internal communications (status reports, leadership updates, 3P updates, company newsletters, FAQs, incident reports, project updates, etc.).
Fundamental design principles for writing maintainable, testable Python code.
responsive-design
Modern responsive layouts using container queries, fluid typography, CSS Grid, and mobile-first strategies.
Generate Playwright tests from scenarios using interactive browser exploration and validation.
Automated website exploration and test case generation using Playwright.
Modern React state management with Redux Toolkit, Zustand, Jotai, and React Query for every state category.
gdpr-data-handling
GDPR-compliant data handling with consent management, data subject rights, and privacy controls.
Python error handling patterns including input validation, exception hierarchies, and partial failure handling. Use when implementing validation logic, designing exception strategies, handling batch processing failures, or building robust APIs.
refactor-plan
Detailed multi-file refactor planning with safety checks and rollback guidance.
