AI-powered engineering. Multi-model collaboration. Software evolution.

FlossWare builds and evolves complex software using coordinated AI engineering systems. Rather than prompting a single model and shipping the result, FlossWare treats 200+ language models as engineering tools -- orchestrated through consensus, adversarial verification, and evolutionary optimization -- to produce software that no single model could build or review alone.

The AI is the engineering method. The software is the product.

Software built by one AI model inherits that model's blind spots. Code reviewed by the same model that wrote it confirms its own assumptions. Parameters tuned by hand reflect the operator's guesses, not measured outcomes.

Instead of trusting one model, FlossWare coordinates 200+ models from 8+ providers (Anthropic, OpenAI, Google, Groq, Cerebras, DeepSeek, and others) across a distributed fleet. Models write code, then independent panels review it with zero overlap. Separate panels adversarially challenge those reviews. Genetic algorithms evolve better configurations over time. The result is software built through independent verification at every stage.

The AI engineering systems described here produce real software. These are not demos or chatbot wrappers -- they are standalone projects that solve specific problems:

These projects are written, reviewed, and evolved using the multi-model engineering pipeline. The AI doesn't just assist -- it writes the code, reviews its own work through adversarial panels, and evolves its approach based on execution history.

AI models are components, not the product. The 200+ models are interchangeable tools in an engineering pipeline. When a model improves or a provider changes pricing, the system routes around it. No single model is essential.

Consensus and orchestration are engineering tools. Multi-model consensus exists to catch bugs that single-model review misses. Adversarial verification exists to prevent self-confirmation. These are quality engineering practices implemented through AI, not AI features implemented for their own sake.

The goal is better software, not better chatbots. Every system described here -- scraping, embedding, routing, evolution -- serves one purpose: produce software that works correctly and survives independent scrutiny.

Evolution over configuration. Don't hand-tune parameters. Let genetic algorithms search the configuration space using real execution history as fitness data.

Interfaces over implementations. Every component communicates through REST APIs. The orchestrator doesn't know if a worker is a server or a Raspberry Pi. Any component can be replaced without touching the others.

For the full design philosophy, see Design Philosophy.

The signature engineering practice. Code changes pass through four phases -- Review, Meta-Review, Fix, Verify -- where review and meta-review panels share zero models to prevent self-confirmation bias. Each phase uses a different arbiter. External reviewers (Grok, ChatGPT, Notebook LLM) provide independent adversarial critique outside the orchestrator entirely.

88+ scrapers collect documents across 12+ domains. A 4-stage async pipeline (store, chunk, embed, graph) converts raw content into searchable vector embeddings and graph-linked knowledge. This grounds AI-generated code in real documentation -- 315,000+ documents, 705,000+ embeddings, 0.4ms vector search -- reducing hallucination and ensuring generated code follows actual API patterns.

Seven GA optimizers evolve model routing, team composition, RAG parameters, prompt templates, and workflow configurations using real execution history as fitness data. The system doesn't stay static -- it measures what works and evolves toward better outcomes.

9 nodes (1 controller + 8 workers) spanning three CPU architectures (x86_64, ARM64, ARMv7) connected via SSH. All 200+ models accessed via free-tier APIs. Circuit breakers, provider fallback, and rate limiting ensure the engineering pipeline stays operational.

┌─────────────────────────────┐
│     Clients / Agents        │
└──────────────┬──────────────┘
               │ REST API
┌──────────────▼──────────────┐
│   Orchestrator (Flask API)  │
│  Routing ─ Consensus ─ GA   │
└──────┬──────────┬───────────┘
       │ SSH      │ API
┌──────▼──────┐ ┌─▼───────────┐
│ Worker Fleet│ │ 200+ LLMs   │
│ (8 nodes)   │ │ (8+ provs)  │
└──────┬──────┘ └─────────────┘
       │
┌──────▼──────────────────────┐
│   Knowledge Platform        │
│ PostgreSQL ─ Redis ─ OrientDB│
│ Vectors ─ Queues ─ Graph    │
└──────┬──────────────────────┘
       │
┌──────▼──────────────────────┐
│   Learning Engine           │
│ Thompson Sampling ─ GA ─    │
│ Feedback Loop Optimizer     │
└─────────────────────────────┘

For the complete architecture, see the Architecture Guide.

FlossWare consists of 37 repositories. The AI engineering pipeline builds and maintains software across all of them.

New to FlossWare?

1. Read this README
2. Explore the Architecture Guide
3. Clone consensus-ai
4. Run the example workflows
5. Explore the remaining repositories

# Clone the orchestration framework
git clone https://github.com/FlossWare/consensus-ai.git

# Or explore the architecture documentation
git clone https://github.com/FlossWare/.github.git

See Getting Started for the full setup guide.

FlossWare is open to contributions from developers, AI practitioners, and infrastructure engineers. See Contributing for guidelines.

The models will change. The software endures.

Built with multi-model engineering. Reviewed by adversarial panels. Evolved by genetic algorithms.