FlossWare

OPEN SOURCE · AI · ENGINEERING

Software systems built to stay understandable.

FlossWare is a free-first engineering ecosystem for modular infrastructure, AI-assisted systems, distributed services, and reusable open-source foundations.

Explore GitHub Explore the architecture

Openstandards first

Modularloosely coupled systems

AI-firstLoom execution substrate

Documenteddecisions and provenance preserved

What is FlossWare?

FlossWare builds reusable engineering foundations and reference implementations using open standards, explicit configuration, stable contracts, and loosely coupled architectures.

The goal is deliberately unfashionable: make powerful systems understandable, replaceable, and maintainable.

Architecture

Loom, Workers, Arbiters, model selection, capability boundaries, provenance, and the rules that keep the system composable.

Repository boundaries

What belongs in each FlossWare repository and where integration should happen without copying implementation.

Knowledge

Acquisition, provenance, derived artifacts, retrieval, and the Git-backed human knowledge system.

Architecture

Workers are fundamental.An Arbiter is a Worker that coordinates Workers.

Hard constraints first.Policy, capability, budget, quota, rate, and availability define feasibility.

Contracts over coupling.Capabilities evolve behind stable integration boundaries.

Evidence over diagrams.Executable dogfooding promotes ideas into durable architecture.

                         Intent
                           |
                        Arbiter
                       /      \
                  Worker    Worker
                       \      /
                        Arbiter
                           |
                        evidence
                           |
                       evaluation
                           |
                         result

Model selection

request
  -> candidates
  -> hard constraints
  -> feasible resources / models
  -> selection strategy
  -> invocation
  -> usage / cost / latency / outcome
  -> evaluation / reward
  -> strategy / knowledge update

Architecture documentation

Loom

Loom is the AI-first execution substrate. It turns declarative intent into verified change while remaining deliberately small.

The core executable abstraction is the Worker. Arbiter coordination is ordinary Worker composition. External clients such as Crush, Claude Code, Codex, and Cursor remain outside Loom’s internal execution model and consume Loom through explicit interfaces.

The canonical dogfood path is:

loom-ai/scripts/dogfood.sh

The core gate exercises formatting, linting, tests, package build, Intent construction, Worker execution, Arbiter coordination, completion evaluation, and end-to-end core execution without requiring provider credentials, databases, Redis, OrientDB, containers, or a local model.

Knowledge system

FlossWare keeps one human-readable knowledge corpus:

Obsidian authoring
       |
       v
Git-backed Markdown
       |
       +------> GitHub source/history
       |
       +------> GitHub Pages presentation

Obsidian is the authoring interface. GitHub provides version history and public source. GitHub Pages presents the same Markdown as the public documentation site. There is no second manually synchronized copy of the knowledge base.

Engineering principles

Modular by default — components remain independently usable.
Explicit behavior — infrastructure capabilities are enabled deliberately.
Contracts over coupling — prefer stable interfaces and composition.
Hard constraints before optimization — adaptive strategies operate only within the feasible set.
Provenance is part of the data — derived artifacts remain traceable.
AI-assisted engineering is explicit — automation operates through contracts and validation.
Knowledge is maintained — architecture and decisions remain reviewable and versioned.

Projects

loom-aiAI-first execution substrate built around Intent, Workers, Arbiters, evidence, and evaluation. model-gatewayProvider/model access, feasibility, routing, usage, cost, and provenance boundaries. curses-tuiReusable terminal interaction primitives.

Historical material

Older documentation remains valuable as evidence of architectural evolution, but it is not current authority. In particular, older orchestration, fleet, provider, database, and learning documents may describe superseded systems.

Current architecture wins. Historical documents explain how we got here.

About FlossWare

FlossWare is an open-source engineering effort led by Scot P. Floess (Flossy) spanning distributed systems, search, AI/ML, infrastructure automation, and open-source tooling.

For the professional résumé and background, visit sfloess.github.io.