npx claudepluginhub plurigrid/asi --plugin asiThis skill uses the workspace's default tool permissions.
> *"A Gödel Machine can rewrite any part of itself, including the learning algorithm, provided it can first prove that the rewrite is beneficial."*
Implements Darwin Gödel Machine patterns for self-improving AI agents with open-ended evolution, lifelong learning, long-term memory, and feedback loops.
Sets up and runs HyperAgents self-improving agent loops from Meta Research, using meta-agents to propose code diffs that optimize task-agents for domains like coding, math, reasoning.
Implements self-improving agent with multi-memory (semantic, episodic, working) that learns from skill experiences to evolve codebases. Auto-triggers on skill hooks for correction and PRs.
Share bugs, ideas, or general feedback.
"A Gödel Machine can rewrite any part of itself, including the learning algorithm, provided it can first prove that the rewrite is beneficial." — Jürgen Schmidhuber
The Gödel Machine is a self-improving system that:
┌─────────────────────────────────────────────────────┐
│ GÖDEL MACHINE │
├─────────────────────────────────────────────────────┤
│ ┌─────────────┐ ┌─────────────┐ │
│ │ Policy │───▶│ Prover │ │
│ │ (current) │ │ (verifier) │ │
│ └─────────────┘ └──────┬──────┘ │
│ ▲ │ │
│ │ ┌──────▼──────┐ │
│ │ │ Candidate │ │
│ │ │ Policy │ │
│ │ └──────┬──────┘ │
│ │ │ │
│ ┌──────┴──────┐ ┌──────▼──────┐ │
│ │ Rewrite │◀────│ Utility │ │
│ │ if proof │ │ Check │ │
│ └─────────────┘ └─────────────┘ │
└─────────────────────────────────────────────────────┘
Combines evolutionary search with formal proofs:
class DarwinGodelMachine:
"""
DGM: Open-ended evolution of self-improving agents.
Archive of agents, LLM-based mutation, fitness evaluation,
keep if novel and beneficial.
"""
def __init__(self, initial_agent: Agent, prover: TheoremProver):
self.archive = [initial_agent]
self.prover = prover
self.generation = 0
def evolve_step(self) -> Agent:
# Sample parent from archive (fitness-proportionate)
parent = self.sample_archive()
# LLM-based mutation
child = self.llm_mutate(parent)
# Evaluate on benchmarks
fitness = self.evaluate(child)
# Optionally: verify improvement formally
if self.prover.can_prove(f"utility({child}) > utility({parent})"):
child.proven = True
# Add if novel and good
if self.is_novel(child) and fitness > 0:
self.archive.append(child)
return child
def llm_mutate(self, agent: Agent) -> Agent:
"""Use LLM to generate improved version."""
prompt = f"""
Current agent code:
{agent.code}
Current fitness: {agent.fitness}
Suggest an improvement to make this agent better.
Return only the improved code.
"""
new_code = self.llm.generate(prompt)
return Agent(code=new_code, generation=self.generation + 1)
module GodelMachine
def self.attempt_improvement(current_policy, seed)
gen = SplitMixTernary::Generator.new(seed)
color = gen.next_color
# Generate candidate via color-guided mutation
candidate = mutate(current_policy, color)
# Attempt proof
proof = attempt_prove(candidate, current_policy)
if proof[:success]
{
improved: true,
new_policy: candidate,
proof: proof[:theorem],
trit: 1 # Generator role
}
else
{ improved: false, reason: proof[:failure_reason] }
end
end
end
# Self-Improvement Triads
kolmogorov-compression (-1) ⊗ cognitive-superposition (0) ⊗ godel-machine (+1) = 0 ✓
proofgeneral-narya (-1) ⊗ self-evolving-agent (0) ⊗ godel-machine (+1) = 0 ✓
sheaf-cohomology (-1) ⊗ epistemic-arbitrage (0) ⊗ godel-machine (+1) = 0 ✓
| Speaker | Relevance | Repository/Talk |
|---|---|---|
| cryptax | Malware evolution/mutation | droidlysis |
| unixfreaxjp | Self-modifying malware | r2con malware analysis |
| cmatthewbrooks | Binary mutation analysis | malchive |