QonQrete is a Secure AI Construction Loop System, using a Multi-Agent Pipeline Orchestrator in a Sandbox environment with YAML Configuration. In short: it spawns 3 AI agents in a sandbox/container and makes them work together on tasks. It can run with a hard requirement for user approval between steps, or in a fully autonomous mode where it keeps running until the user decides to stop it.

QonQrete is a multi-agent orchestration system designed for secure, observable, and human-in-the-loop software construction. It operates on the principle of a secure build environment (Qage), managed by a host-level orchestrator (Qrane).

This architecture ensures that AI-generated code and processes cannot affect the host system, providing a robust framework for autonomous and semi-autonomous development.

Version: v0.9.0-beta (See VERSION file for the canonical version).

Note on TUI Mode and Agent Testing:

The Text-based User Interface (TUI) mode is currently under active development and may still have bugs. While the agent setup is dynamic, extensive testing is still required.

We welcome community contributions! If you encounter any issues or have suggestions, please report them. Your feedback is invaluable in helping us improve the system.

A new agent that supercharges your tasq.md automatically on Cycle 1:

+15-20% improvement in output quality!

# config.yaml - TasqLeveler uses instruqtor's config by default
agents:
  tasqleveler:
    provider: openai
    model: gpt-4.1-mini

One simple rule for ALL cycles:

• 📁 File EXISTS? → MODIFY/EXTEND it (never recreate)
• 📄 File MISSING? → CREATE it (new modules welcome!)

No more rebuild-from-scratch bugs on multi-cycle builds!

A new policy-driven hybrid caching agent with Variable Fidelity:

• Policy-Based Configuration: All behavior controlled via caching_policy.yaml
• 6 Operational Modes: local_fast, local_smart, cyber_bedrock, cyber_aggressive, paranoid_mincloud, debug_repro
• Variable Fidelity: Intelligently mixes full code (MEAT) + skeletons (BONES)
• Schema Validation: Bad YAML can't brick your flow
• Improved Volatile Detection: Cycle-based, diff-based, git diff, mtime fallback

# Select mode in config.yaml
agents:
  qontrabender:
    policy_file: "./caching_policy.yaml"
    mode: "local_smart"

See QONTRABENDER.md for full documentation.

QonQrete now features a Triple-Core Memory System:

┌─────────────────────────────────────────────────────────────────────────┐
│                    THE DATA LAKE (Local)                                │
│                                                                         │
│   qodeyard/ (MEAT)           bloq.d/ (BONES)        qontext.d/ (SOUL)   │
│   Full source code           AST skeletons          Semantic maps       │
│                                                                         │
│             │                        │                      │           │
│             └───────────┬────────────┴──────────────────────┘           │
│                         ▼                                               │
│              ┌───────────────────────┐                                  │
│              │    QONTRABENDER       │ ← Policy-driven compositor       │
│              │   caching_policy.yaml │                                  │
│              └──────────┬────────────┘                                  │
│                         ▼                                               │
│                   qache.d/ (Cache Ledger)                               │
│                   └─ Variable fidelity payloads                         │
└─────────────────────────────────────────────────────────────────────────┘

Scenario: Medium-sized project (50 files, ~10,000 lines of code)

1. Isolation by Design: All agent execution occurs within the Qage, a Docker container that acts as a secure sandbox.
2. Configuration-Driven: Agent models, modes, and policies defined in YAML.
3. File-Based Communication: Agents communicate via markdown files, creating transparent audit trails.
4. Human-in-the-Loop Control: CheQpoints pause for user review. Can be configured for autonomous mode.
5. Local Sovereignty: Keep intelligence local with policy-driven caching.

• qrane/: The Qrane orchestrator and CLI
• worqer/: AI agent scripts (tasqLeveler, instruQtor, construQtor, inspeQtor, qompressor, qontextor, qontrabender)
• worqspace/: Shared data plane with configuration and generated artifacts

1. Enhance (tasqLeveler): Cycle 1 only - Supercharges tasq with golden paths and mocks
2. Plan (instruQtor): Reads the tasQ and creates briQ files with detailed plans
3. Execute (construQtor): Processes each briQ and generates code in qodeyard/
4. Review (inspeQtor): Reviews generated code and produces reQap with assessment
5. CheQpoint (gateQeeper): Pauses for user command to proceed

• macOS: Docker Desktop for Mac
• Linux: sudo apt-get install docker-ce docker-ce-cli containerd.io
• Windows: Docker Desktop for Windows

Docker Desktop Users: Grant Docker permission to access the project directory via Settings > Resources > File Sharing.

Lightweight alternative to Docker. See Microsandbox repository.

See QUICKSTART.md for the full guide.

Export keys for your AI providers:

export OPENAI_API_KEY='your-key'
export GOOGLE_API_KEY='your-key'
export ANTHROPIC_API_KEY='your-key'
export DEEPSEEK_API_KEY='your-key'

./qonqrete.sh init

# With TUI
./qonqrete.sh run --tui --mode security

# Autonomous mode
./qonqrete.sh run --auto --briq-sensitivity 2

# User-gated mode
./qonqrete.sh run --user

./qonqrete.sh clean

agents:
  tasqleveler:
    provider: openai
    model: gpt-4.1-mini  # Runs once on Cycle 1
    
  instruqtor:
    provider: openai
    model: gpt-4.1-mini

  construqtor:
    provider: gemini
    model: gemini-2.5-pro

  inspeqtor:
    provider: openai
    model: gpt-4.1

  qontextor:
    provider: local
    model: qontextor
    local_mode: complex

  qompressor:
    provider: local
    model: qompressor

  qontrabender:
    provider: local
    model: qontrabender
    policy_file: "./caching_policy.yaml"
    mode: local_smart

options:
  use_qompressor: true
  use_qontextor: true
  use_qontrabender: true
  cheqpoint: false
  auto_cycle_limit: 4

• QUICKSTART.md - Getting started guide
• DOCUMENTATION.md - Full system documentation
• QONTRABENDER.md - Cache bender documentation
• RELEASE-NOTES.md - Version history
• TERMINOLOGY.md - QonQrete terminology

QonQrete is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0). See the LICENSE file for full text.