cargo
Rust package manager (36 subcommands).
Full skill instructions
Trit: 0 (ERGODIC - coordinates the ontology)
Foundational 5-layer ontology for agent-o-rama. Agents are not primitives—they emerge from derivations, stalks, and sections when gluing succeeds.
Layer 4: EMERGENT agent, skill, experiment
↑
Layer 3: OPERATIONAL node, emit, aggregation, result
↑
Layer 2: SHEAF stalk, section, cohomology
↑
Layer 1: DERIVATIONAL derivation, chain
↑
Layer 0: PRE-ONTOLOGICAL seed, trit, γ (gamma)
| Term | Type | Definition |
|---|---|---|
| seed | uint64 | Deterministic state replacing time |
| trit | {-1, 0, +1} | GF(3) charge element |
| γ | constant | 0x9E3779B97F4A7C15 (golden ratio bits) |
| Term | Type | Definition |
|---|---|---|
| derivation | (Seed × Trit) → (Seed × Section) | Fundamental computation unit |
| chain | [Seed] | Sequence of derived seeds |
Rule: seed_{n+1} = splitmix64(seed_n ⊕ (trit_n × γ))
| Term | Type | Definition |
|---|---|---|
| stalk | Set(Section) | Collection of sections over one trit |
| section | local data | Output of derivation, can glue |
| cohomology | (H⁰, H¹) | Global sections and obstructions |
Stalk Distribution (2-3-2):
MINUS: 2 elements, trit=-1, role=validator
ERGODIC: 3 elements, trit=0, role=coordinator
PLUS: 2 elements, trit=+1, role=generator
Verification: 2(-1) + 3(0) + 2(+1) = 0 ✓
| Term | Sheaf Correspondence |
|---|---|
| node | section-producer |
| emit | stalk transition |
| aggregation | gluing (cocycle check) |
| result | global section (H⁰ element) |
| Term | Definition |
|---|---|
| agent | Fiber bundle over trit poset {-1, 0, +1} |
| skill | Executable section (self-contained knowledge) |
| experiment | Derivation chain evaluation |
Key: Agent = Observation(Bundle(Stalk₋₁, Stalk₀, Stalk₊₁))
| ID | Invariant | Formula | Verified By |
|---|---|---|---|
| I1 | GF(3) Conservation | Σ trits ≡ 0 (mod 3) | aggregation, trifurcate |
| I2 | Determinism | derive(s,t) = derive(s,t) | seed chaining |
| I3 | Order Independence (SPI) | parallel(f) = sequential(f) | spi-parallel-verify |
| I4 | Gluing (Cocycle) | g_ij ∘ g_jk = g_ik | cohomology check |
| I5 | Bisimulation | A ~ B ⟺ ∀obs. obs(A) = obs(B) | bisimulation-game |
64-bit unsigned integer replacing temporal state. Same seed → identical derivation chains.
GF(3) element in {-1, 0, +1}. Forms a field under modular arithmetic.
Fundamental computation: (Seed × Trit) → (Seed × Section)
Replaces temporal succession with seed-based chaining.
Collection of sections over a single trit value. Organized as fiber bundle.
Local data produced by derivation. Sections glue to form global sections when cocycle condition holds.
Every operation MUST split into three sub-derivations:
intent
│
┌────────┼────────┐
▼ ▼ ▼
MINUS ERGODIC PLUS
(-1) (0) (+1)
validate coordinate generate
│ │ │
└────────┼────────┘
▼
aggregate
(verify Σ=0)
| Sub-Agent | Trit | Role | Skills |
|---|---|---|---|
| MINUS | -1 | Validator | spi-parallel-verify, bisimulation-game |
| ERGODIC | 0 | Coordinator | glass-bead-game, triad-interleave |
| PLUS | +1 | Generator | gflownet, self-evolving-agent |
(def GENESIS-SEED 0x42D)
(def GAMMA 0x9E3779B97F4A7C15)
(def MIX1 0xBF58476D1CE4E5B9)
(def MIX2 0x94D049BB133111EB)
(defn derive-seed [seed trit]
(let [adjusted (bit-xor seed (* trit GAMMA))]
(splitmix64-next adjusted)))
(defn derivation-chain [genesis-seed trits]
(reductions derive-seed genesis-seed trits))
(defn gf3-add [a b]
(let [sum (+ a b)]
(cond (> sum 1) (- sum 3)
(< sum -1) (+ sum 3)
:else sum)))
(defn gf3-conserved? [trits]
(zero? (reduce gf3-add 0 trits)))
;; Scatter: emit three roles
(aor/agg-start-node
"scatter"
"execute-role"
(fn [agent-node {:keys [intent]}]
(aor/emit! agent-node "execute-role" {:intent intent :role :minus})
(aor/emit! agent-node "execute-role" {:intent intent :role :ergodic})
(aor/emit! agent-node "execute-role" {:intent intent :role :plus})))
;; Gather: verify conservation
(aor/agg-node
"execute-role"
nil
aggs/+vec-agg
(fn [agent-node requests _]
(let [results (mapv execute-role requests)
trits (mapv :trit results)
conserved? (gf3-conserved? trits)]
(aor/result! agent-node {:conserved conserved? :trits trits}))))
Before any operation completes:
This skill connects to the K-Dense-AI/claude-scientific-skills ecosystem:
general: 734 citations in bib.duckdbThis skill maps to Cat# = Comod(P) as a bicomodule in the equipment structure:
Trit: 0 (ERGODIC)
Home: Prof
Poly Op: ⊗
Kan Role: Adj
Color: #26D826
The skill participates in triads satisfying:
(-1) + (0) + (+1) ≡ 0 (mod 3)
This ensures compositional coherence in the Cat# equipment structure.
Rust package manager (36 subcommands).
Translate Figma nodes into production-ready code with 1:1 visual fidelity using the Figma MCP workflow (design context, screenshots, assets, and project-convention translation). Trigger when the user provides Figma URLs or node IDs, or asks to implement designs or components that must match Figma...
**Status**: 🌳 Production Ready (upstream in StringZilla v3+) **Type**: High-Performance String Operations / SIMD-Accelerated Text Processing **Principle**: Zero-copy views, SIMD/SWAR acceleration, deterministic hashing **Frame**: Cross-language interoperability (C, C++, Python, Rust, Go, Swift, ...
Conformal Geometric Algebra (CGA) for circles, spheres, and Möbius transformations
Verifies code implements exactly what documentation specifies for blockchain audits. Use when comparing code against whitepapers, finding gaps between specs and implementation, or performing compliance checks for protocol implementations.
Systems programming and performance optimization using Zig. Provides low-level abstractions, memory-safe compiled code, and performance benchmarking. Use for system-level operations, optimization, and interoperability with C/POSIX APIs.
PayPal MCP server integration for invoices, payments, subscriptions, disputes, and transaction reporting via @paypal/mcp.
Unison language - content-addressed functional programming with abilities for effects, distributed computing, and structural types. Use for pure functional code, effect management, distributed systems, and refactoring-safe codebases.
Google Tasks management via TasksACSet. Transforms task operations into GF(3)-typed Interactions, routes to triadic queues, detects saturation for task-zero-as-condensed-state.
World C Skill
Syrup binary serialization for OCapN/CapTP wire format. Canonical encoding for capability messages.
Install Codex skills into $CODEX_HOME/skills from a curated list or a GitHub repo path. Use when a user asks to list installable skills, install a curated skill, or install a skill from another repo (including private repos).
Generate, edit, and beat-sync AI video with leading models in one workspace.
The world's fastest calendar for remote work
Transform Your Design with AI Designer by ImgCreator.ai
Revolutionizing Video Production with AI-Powered Creativity
Extend an image past the frame and let AI fill the new aspect ratio.
Discover your celebrity doppelgänger with StarByFace!
ChainClarity explains 700+ crypto whitepapers in plain English, with layered summaries, comparisons, research tools, alerts, and a $4.99 Pro plan.
Opus.ai: Revolutionize Your Web Experience