PROJECT-R2

The Observation

A raw language model does one thing by default:

prompt → predict next token → append → predict next token → repeat

One forward pass. Token by token. No internal review. No second thoughts. Whatever comes out first is what you get.

I noticed something while using these tools daily. When an answer wasn't good enough, I'd type "revise this" or "improve it further" — and it would. Every single time. A noticeably better answer. It would even explain exactly where the gaps in its first response were.

The model isn't broken. The model is capable of significantly better than its first response. The problem is that every mainstream AI interface stops at one pass and hands you the draft.

PROJECT-R2 automates the revision loop you were already doing manually.

The Problem

Beyond the single-pass issue, there's a second wall: these tools have no memory of your work.

Mid-session, deep into a problem — the AI forgets what was decided three messages ago. Gives a generic answer that ignores the stack you're working with. You re-explain the entire context every time you open a new chat. The longer the session, the more context bleeds out.

Two separate problems. Both hitting at once. One about quality. One about memory.

The problem isn't the model. The problem is the interface built around it — one that never asks the model to think twice.

How It Works

PROJECT-R2 sits between you and the model. Before any answer reaches you, it runs the revision loop internally — the same loop you were running manually, now automated.

This is what AI research calls reflection, debate, and iterative refinement — techniques used in serious AI systems. Most of that logic lives outside the model, orchestrated externally. That's exactly what this is.

Context Memory System

The refinement loop only works well if the model knows your project. Generic context produces generic answers regardless of how many passes run.

Instead of sending the full conversation history on every call — expensive, slow, hits token limits fast — PROJECT-R2 maintains a living structured memory that evolves with your session:

{
  "project":          { "name": "", "stack": "", "entry_point": "" },
  "files":            { "filename": "one line description" },
  "decisions":        ["what was decided + why"],
  "failed_attempts":  ["what failed + why"],
  "working_patterns": ["what works + how"],
  "current_task":     { "goal": "", "status": "", "blockers": "" }
}

A Summarizer Agent reads the conversation every 10 messages and extracts only the facts that affect future answers. Narrative is dropped. Specifics — exact file names, decisions made, what failed and why — are kept.

When tokens approach the limit, a Smart Cleanup Agent categorizes every item in context:

The agent decides what's safe. You confirm. The session continues without losing anything that matters.

Task-Aware Model Selection

PROJECT-R2 is not a coding-only assistant. Different tasks need different models. When you start a task, you select the mode — the system routes accordingly:

All models accessed via OpenRouter. Routing handled internally. During development: free tier only. When commercial: model swap requires zero architecture change.

Architecture Overview

Current Development Status

Building Plan

Stack