Self-improving long-term AI · in development

An AI that remembers
because it dreams.

flowchart TB
    classDef core fill:#1a1315,stroke:#c93828,color:#e6e1cc

    DAWNLOOP["DawnLoop"]

    subgraph engine["the engine — five agents · one memory graph"]
        direction TB
        REACTOR["Reactor"]
        PLANNER["Planner"]
        REVIEWER["Reviewer"]
        EXECUTOR["Executor"]
        DREAMER["Dreamer™"]:::core
        MEMORY["Memory Graph"]
        NIGHT["Nightly Pass™"]:::core
        REACTOR -->|escalates| PLANNER
        REACTOR -->|executes| EXECUTOR
        PLANNER -->|directs| EXECUTOR
        REVIEWER -->|scores| EXECUTOR
        EXECUTOR -->|records| DREAMER
        EXECUTOR -->|accesses| MEMORY
        DREAMER -->|consolidates| MEMORY
        DREAMER -.->|nightly| NIGHT
    end

    subgraph tools["integrations"]
        direction LR
        GITHUB["GitHub"]
        JIRA["Jira"]
        GDRIVE["Google Drive"]
        NOTION["Notion"]
        MCP["Other MCPs"]
        GITHUB ~~~ JIRA ~~~ GDRIVE ~~~ NOTION ~~~ MCP
    end
    tools --> DAWNLOOP
    EXECUTOR --> DAWNLOOP
    DAWNLOOP --> Slack["Slack"]
    DAWNLOOP --> Teams["Teams"]
    DAWNLOOP --> WhatsApp["WhatsApp"]
    style engine fill:none,stroke:none
    style tools fill:none
    style DAWNLOOP fill:#301a1c,stroke:#ff5a41,stroke-width:2px,color:#ffe9d6,box-shadow:0 0 22px #c938288c

01 — The problem

Memory isn't the same as accumulation.

Assistants have memory features now — a saved preference, a project instruction, a recalled fact. What most of them still lack is consolidated accumulation: a growing, self-correcting account of how your team actually works, with provenance, contradiction handling, and outcome supervision. Three limits follow from that.

• Recall isn't understanding.Storing what you said is easy. Turning a year of work into a small set of durable, correct beliefs about your conventions and decisions is the hard part — and it's the part nobody does.
• Nothing is ever resolved.When this month's decision contradicts last quarter's, a memory store keeps both and hands you whichever it found. No consolidation, no pruning, no idea which one is live.
• Retrieval runs on a stopwatch.Every lookup happens while you wait, so it stays shallow by necessity. The genuinely expensive thinking never gets done, because there's no moment when it's free.

Longer context windows don't fix this — they just raise the ceiling on how much undigested material you can paste in. Understanding is built by consolidation, and consolidation takes time that a request-time lookup doesn't have.

02 — How it works

No single model should do everything. DawnLoop is designed as a crew of specialists — like a brain, not a monolith. Each has a job, a memory access path, and a role in the nightly pass. Under the hood, the architecture is designed to work with self-hosted models or cloud providers rather than locking you to one vendor.

• Reactor — reacts.The instinct. Pattern-matches the familiar and answers fast, in under a second. Routes the hard things onward instead of blocking on deep thinking.
• Planner — reasons.The prefrontal cortex. Deliberate, strategic, expensive — so it only wakes when the Reactor escalates. Maps goals to steps.
• Executor — does.The hands. Writes the code, drafts the message, takes the action. Records every action as an experience, and attaches the outcome when the outcome is known.
• Reviewer — judges.The second opinion. Scores outputs before they ship and feeds the signal back.
• Dreamer — consolidates.The night. Turns the day's experiences into durable knowledge. The reason DawnLoop is designed to compound.

Reactor fires first, always. Only novel or complex work escalates to the Planner — so common requests stay fast and cheap, and hard problems still get real reasoning. It's a routing tier, and the thing that makes it better than routing on text alone is that the Reactor can see the memory graph: it knows this is the fortieth time you've asked.

03 — The memory

A graph, not a file cabinet.

DawnLoop's memory is the system — a growing associative graph with two layers, loosely borrowed from how the brain splits episodes from concepts.

• Episodic layerraw experiences as events: who, what, when, where, outcome. Linked to the files they touched, the decisions they implemented, the bugs they caused.
• Semantic layerdistilled beliefs about how you work, built from those episodes during the nightly pass. Each one carries its provenance, its confidence, and when it was last confirmed.
• Recall by pattern completiongive it a cue and the graph is walked from there, pulling the corner that matters. Typed edges, not undifferentiated chunks.
• Weighted by what matteredwhat caused a revert, what gets used constantly, what's been confirmed recently, what's being contradicted. Retrieval is ranked by consequence, not just similarity.
• Tiny context, alwaysthe graph is the warehouse; the context window is the workbench. We never load the warehouse.

This is retrieval — we're not going to pretend otherwise. The bet is that retrieval over a consolidated graph, where beliefs carry provenance and contradictions get resolved overnight, beats retrieval over a pile of embedded text chunks. The memory and orchestration layer is model-agnostic by design: it can work with self-hosted models or cloud providers, depending on the deployment's needs. That's a claim we intend to prove with numbers, not adjectives.

04 — The sleep

The expensive thinking happens while you sleep.

Consolidation is the costly part, and nobody has to be waiting for it. DawnLoop is designed to do that work overnight, when latency is free — replaying the day, extracting what generalizes, and resolving what contradicts.

1. Replay — re-walk the day's experiences, now joined to how they actually turned out.
2. Consolidate — extract the rules that generalize, and write them down with their evidence attached.
3. Prune — fade what's gone stale; retire what the day's outcomes contradicted.
4. Strengthen — reinforce what mattered and what's used often.

The signal that makes this work is outcomes. Tests pass or fail. Pull requests merge or get reverted. Builds break. Those are facts from the world, not a model's opinion of its own work — and they're what separates consolidation from an AI grading its own homework.

There's a further step we think is possible: distilling each night's consolidated knowledge into the model's own weights. We're treating that as a research bet, not a promise. It ships only if it beats the memory-only version on a real evaluation, and it never reaches you without a one-click way back to yesterday. Everything above works without it.

05 — Where it lives

One core. Starting with code.

One self-improving core, surfaced where you already work — built for developers first, and deliberately in that order.

• DawnLoop Code*first, and the focus.* The pair programmer designed to know your codebase's history: architectural decisions, conventions, the bug you already fixed twice. Not autocomplete with context — an engineer who remembers why you chose that database. We start here because the memory is concrete and the feedback is real: tests, merges, and reverts tell it when it was wrong.
• DawnLoop Work*later.* The colleague who remembers every decision and its reason, and flags it when today contradicts what the team agreed in March.
• DawnLoop Chat*later still.* The Slack teammate designed to learn your channels' rhythm and history.

One core: graph memory, five agents, nightly consolidation. We'd rather make it genuinely good for one kind of work than shallow across three — so DawnLoop Code is what we're building now, and the others come when it's earned.