Forge Mode // Self-improving code engine

It writes.
It criticises itself.
It gets it right.
Then it learns.

Dream isn't a single code generation pass. It's a refinement loop — an Implementer writes the solution, a Critic finds every flaw, and they iterate until the code actually works. When it passes, Celestos forges a Skill from what it learned. Next time, it starts from mastery, not scratch.

The loop // Implementer → Critic → iterate → forge

Not a single shot. A grind toward correct.

Most code generation is one pass — you get an attempt and you debug it yourself. Dream runs a full internal critique loop. Two agents, one task, no exit until it passes or you stop it.

Phase 1
Implementer

Writes a complete, precise solution to your task. No placeholder code. No "you'll need to fill this in." A real implementation.

Phase 2
Critic

Analyses the implementation against the original task. Looking for bugs, missing requirements, logic gaps. If it finds nothing: PASS.

Phase 3
Iterate

If the Critic finds issues, it feeds precise error notes back to the Implementer. The Implementer revises. This cycle runs up to 5 times.

Phase 4
Forge

Once it passes, Celestos writes a Skill from everything it learned — the patterns, the pitfalls, the correct solution. Saved to your vault permanently.

Live trace // Watch it work

Every iteration is visible. Nothing is hidden.

Dream streams every step into chat as it runs. You see the Implementer's attempt, the Critic's diagnosis, the revision, and the final verdict. If it fails after 5 iterations, you see exactly why — and you have the closest solution as a starting point.

Write a rate-limited API client in Python with exponential backoff and retry logic
Build a CSV-to-JSON transformer that handles malformed rows gracefully
Create a React hook that debounces input and cancels stale requests
Write a bash script that backs up only changed files since last run
Build a parser for this custom log format with error recovery
Live trace — what you see
Dream · Starting sequence Task: rate-limited API client, Python Iter 1/5 · Implementer generating... Iter 1/5 · Critic diagnostic running... ✗ FAIL Missing: connection timeout handling retry count not exposed to caller Iter 2/5 · Implementer revising... Iter 2/5 · Critic diagnostic running... ✓ PASS All requirements met Forge · Writing Skill from this session Skill saved: skills/autogenous/ dream-rate-limited-api-client/SKILL.md
Autogenous skills // Celestos learns from its own work

Every solved problem becomes permanent expertise.

After each passing Dream run, Celestos reflects on the full session — the pitfalls hit, the patterns that worked, the exact solution — and writes a Skill. This Skill is saved to your vault and auto-injects the next time you ask for something similar. The hard problem becomes easy. Permanently.

What the skill contains
The exact correct pattern for the task
The pitfalls the Critic caught — so future runs avoid them
Keyword triggers — the skill auto-activates on matching requests
Saved permanently in your Skills vault under autogenous/
What happens next time
You ask for a similar solution — the Skill auto-injects before the model responds
The model starts from the proven pattern, not a blank slate
First-pass quality is dramatically higher — no iteration needed
Celestos compounds knowledge with every Dream run you complete
← Dev & Data Skills & Skill Vault →