How QonQrete takes back AI Thinking Mode & memory (locally, for real)

Hey Indie Hackers 👋

Over the last months I kept running into the same pattern with the big AI tools (Gemini, GPT, etc.):

• “Thinking mode” behavior keeps changing or getting nerfed

• Long chats forget what we agreed on 10 messages ago

• Chain-of-thought is hidden in the UI

• You have no idea how/where any of this “memory” actually lives

For devs and builders, that’s brutal:

• You can’t diff the reasoning

• You can’t grep it

• You can’t version-control it

• And if they change the UI or model behavior, your workflow breaks overnight

So I built my own thing.

What I built: QonQrete

QonQrete is an open-source, local-first agentic AI “construction yard”.

Instead of doing everything inside a black-box chat UI, QonQrete:

• Runs agents on your machine

• Stores all reasoning + memory as plain files

• Treats your repo as the long-term “brain”

• Lets you inspect, diff, grep, and version-control everything

Repo: https://github.com/illdynamics/qonqrete
License: AGPL (open source, but with strong copyleft)

How it gives you back “Thinking Mode” (visible chain-of-thought)

Most tools hide chain-of-thought to avoid “extraction”.
In QonQrete, chain-of-thought is a first-class artifact.

The core pipeline is three agents:

• InstruQtor – plans the work (turns a tasq.md into briqs / steps)

• ConstruQtor – executes the steps inside a sandboxed workspace (“qage” / qodeyard)

• InspeQtor – reviews the result and writes a reqap with assessment + next steps

Each stage writes to disk:

• Console logs → struqture/qonsole_{agent}.log (full streaming output)

• Event logs → struqture/events_{agent}.log (high-level flow)

• Briqs (planning / chain-of-thought) → briq.d/cyqle{N}tasq1_briqXXX_slug.md

• Reqaps (meta-reasoning + next steps) → reqap.d/cyqle{N}_reqap.md

The important part:

InstruQtor’s entire thought process lives in briq files on disk.

That is your “Thinking mode”:

• Not ephemeral

• Not UI-only

• Not locked inside someone else’s product

• Fully diffable / greppable / versionable in git

No provider can hide it because it never lives in their UI in the first place.

How it fixes “broken memory” and context drift

Cloud products try to magically decide what’s “relevant” for you.
Sometimes it works. Sometimes it pulls in a random chat from 3 months ago. Sometimes memory disappears entirely.

QonQrete doesn’t have a mystery memory subsystem.
Memory is literally:

• Files on disk

• Plus your git history

• Plus a deterministic pipeline

The loop looks like this:

1. Cycle 1: tasq.md → briqs → work in qodeyard/ → reqap.md

2. Cycle 2: the previous reqap is promoted to the new tasq.md

3. Cycle N: repeat – context accumulates as files + repo state.

So:

• Memory = artifacts in briq.d/, reqap.d/, exeq.d/, repo files

• Continuity = explicit pipeline logic (promote_reqap() etc.), not opaque heuristics

• Context control = you decide what lives in sqrapyard/ and qodeyard/

You can also “resume” arbitrary brain states:

• Copy any files into sqrapyard/ (notes, partial repo, whatever)

• Put a previous reqap as sqrapyard/tasq.md

• Start a new cycle → QonQrete continues from there

No dependency on “whether your chat history is still around”.

What’s new in v0.6.0: cheaper + faster context (Dual-Core)

One big problem with agentic systems is cost:
Naively stuffing the whole codebase into context every time is expensive and slow.

In v0.6.0-beta, I introduced a Dual-Core Architecture:

1. qompressor (The Skeletonizer)

• Strips implementation bodies from your code

• Keeps function signatures, imports, docstrings

• Produces a tiny, structural “skeleton” of the project

You get high-level architecture, with almost no token cost.

2. qontextor (The Symbol Mapper)

• Walks the skeleton and builds a machine-readable YAML map

• Knows symbols, responsibilities, and relationships

• Becomes the queryable context layer for other agents

So instead of “send all the code”, QonQrete sends:

• The skeleton

• The symbol map

• Only the relevant slices of real code when needed

3. calqulator (The Cost Estimator)

• Looks at planned briqs + context

• Estimates token + cost per cycle

• Annotates tasks with budget info before you run them

No more surprise API bills when experimenting with agents.

How you actually use it (high-level)

Very condensed:

1. Install QonQrete (Python + Docker).

2. Drop your project or seed files into sqrapyard/.

3. Write your task in sqrapyard/tasq.md (e.g. “Refactor auth layer + add tests”).

4. Run the QonQrete script.

5. Watch InstruQtor → ConstruQtor → InspeQtor loop over cycles:

   • Planning briqs

   • Applying changes in qodeyard/

   • Reviewing + writing reqap.md

6. Inspect the artifacts, accept/reject changes, iterate.

Everything is files. If you like, you can git-commit the whole qage as an auditable snapshot of the AI’s reasoning and edits.

Why I’m posting this here

I’m not trying to build yet another glossy AI UI.

I’m trying to build a Unix-style, file-based “thinking/memory layer” that:

• You can run locally

• You can plug into your own tools / CI

• You can debug and inspect like normal code

I’d love feedback from the IH crowd on:

1. Does this solve a real pain for you?

   • Hidden CoT

   • Flaky memory

   • Fear of vendor changes breaking your workflow

2. What’s missing to make this usable in your stack?

   • Better docs?

   • More examples?

   • Pre-built “recipes” (e.g. “refactor + test”, “write initial scaffolding”, etc.)

3. Would you actually run this locally for your product?

   • If not, what’s the blocker? Security? Setup friction? Something else?

Links

• GitHub: https://github.com/illdynamics/qonqrete

• Docs are in the repo (DOCUMENTATION.md, TERMINOLOGY.md, RELEASE-NOTES.md)

If you’re tired of AI “Thinking modes” that you don’t control, I’d really appreciate your eyes on this.
Roast it, poke holes in it, or try it on a side project and tell me where it hurts. 🙏