QonQrete

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. 🙏

## The pain that pushed me to build this

I was frustrated with AI tooling that:

- Runs mostly in the cloud

- Treats privacy as an afterthought

- Gives me almost no control over how and where code is executed

I wanted something that lives on my own machine, works with multiple LLM providers, and treats security + reproducibility as first-class concerns.

So I started hacking on my own system to orchestrate LLMs locally… and it snowballed into QonQrete.

---

## What I built

QonQrete is a local-first, multi-agent AI “construction system” that plans, writes, and reviews code inside a sandboxed workspace.

The core pipeline uses 3 agents:

- InstruQtor – planning: breaks down the task, designs the steps

- ConstruQtor – building: writes/edits code inside a controlled repo

- InspeQtor – reviewing: does code review, sanity checks, and suggests fixes

Each agent can run with your choice of:

- GPT

- Gemini

- Claude

- DeepSeek

- (or other OpenAI-compatible APIs)

You keep everything on your own machine and wire in the models you like.

---

## Why it’s different (at least for me)

A few things that make QonQrete feel different from the usual “AI coding assistant”:

- Local-first: the whole construction loop runs on your machine

- No cloud lock-in: bring your own APIs and swap them out per agent

- Sandbox execution: work happens inside a controlled project folder / “qoreyard”

- Multi-LLM per pipeline step: planning, coding, and reviewing can each use different models

- Human-in-the-loop or autonomous: you can approve steps, or let it run more hands-off

- Very dev-oriented: it’s built for people who live in terminals and care about git history, diffs, and reproducible runs more than pretty UIs

---

## My personal journey with it

This started as a quick experiment to reduce boilerplate in my own projects.

I just wanted a smarter way to:

- Plan features

- Write the boring bits

- Keep everything inside git

But as I kept iterating, it turned into a full system where multiple AI agents collaborate in a structured way. I didn’t expect it to work as well as it does — or to drag me this deep into agent orchestration, prompt chaining, and local-first workflows.

It’s still early, but I’m using it on real projects now and trying to harden it as I go.

---

## What I’d love feedback on

If you use AI in your programming workflow:

- What’s missing for you right now?

- Would you trust a local multi-agent system to modify your repo if you can see every diff and approve steps?

- What features would make something like this actually useful in your day-to-day dev life?

Honest criticism is very welcome — I’d rather hear “this is overkill” or “I’d only use it if X/Y existed” than polite silence.

---

## Repo (open-source, still early)

If you want to poke around the code or try it:

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

It’s still a v0.5.0 beta, but I’d love to hear from anyone who:

- Cares about local-first + privacy-conscious AI dev tooling

- Plays with multi-agent setups

- Has strong opinions about how AI should (or shouldn’t) touch their codebase

Happy to answer any questions here and share more details about the architecture or trade-offs if people are curious.