Software Quality & AI Test Intelligence
Fleury helps engineering and QA teams understand what their software does, which behaviors have been tested and what needs attention before release. It brings application exploration, test discovery and execution, behavioral graphs, quality gates and evidence into one workbench. Its AI assistant helps investigate findings, propose links between behavior and tests, recommend and generate tests, and prepare quality briefs for different stakeholders. I conceived the product, its analysis algorithms and distributed architecture, from the interface to enterprise and self-hosted delivery.
Source code, tests and real application behavior often live in separate tools. A passing test suite does not explain which user journeys remain unexplored, and a failed run can leave teams without enough evidence to diagnose the problem or decide whether a release is ready.
Fleury turns tests and observed application behavior into a traceable basis for release decisions. Teams can navigate a behavioral graph, inspect a failure, review a quality gate and use AI to identify useful follow-up work. Correlations are tied to the source revision, proposals require review, and generated tests carry execution evidence before they count as completed work.
Discover web screens, API endpoints and mobile journeys. Follow states and transitions in a graph, inspect captured evidence, and explore stateful or isolated branches.
Connect a repository, discover supported test suites, build a selection and follow its execution. Inspect failures and compare results across runs.
Use quality scores and gates for tests, exploration or their combined evidence. Review risks, record a decision and share the result with a bounded viewer or CI webhook.
Ask about a finding, run or selected graph element. Review proposed behavior-to-test links with supporting evidence, contradictions and confidence before accepting them.
Review AI recommendations and generated test diffs, then validate them against an exact source revision in an isolated workspace. Execution results remain attached to the recommendation.
Prepare AI-assisted quality briefs for QA, engineering, product, release and compliance. Review cited evidence, publish a version and export it in English or French.
Manage teams, roles, SSO and provisioning. Use the workbench or CLI with cloud, self-hosted and air-gapped delivery options.
Representing meaningful application states without multiplying equivalent screens or losing the provenance of a transition.
Keeping exploration and test intelligence independent while correlating results from the same source revision.
Recovering long-running execution after interruptions without duplicating commands, losing evidence or leaking isolated environments.
Supporting different browser, API and mobile runners while exposing their actual capabilities and limitations.
Grounding AI proposals in execution evidence and keeping human review, generated code, test results and release decisions as distinct steps.
Delivering the same product in cloud and self-hosted environments with consistent identity, access and release contracts.
Fleury separates product control, durable orchestration, runner execution and the event plane. The Go control plane owns PostgreSQL state and commands; Temporal coordinates long-running work, and separate runner hosts act on web, API and mobile targets. Rust analyzers run across process boundaries. Evidence is stored in object storage, secrets in a secrets store, and reviewed AI jobs use a provider adapter. The views below distinguish this runtime from the Kafka/CDC plane, the self-hosted package and container and Kubernetes deployment variants.
The Go control plane owns product state in PostgreSQL. Temporal coordinates long-running work, while separate runner hosts execute application actions and return evidence.
The Go control plane and PostgreSQL own product state. Event transport and derived read models have separate responsibilities, shown in the second view.
Temporal coordinates durable work. Runner agents act on applications; Playwright performs browser actions and CDP observes. Rust analyzers are process boundaries, not an invented public microservice.
The mono-host package dispatches the PostgreSQL command journal directly to Temporal without requiring Kafka. Its runner pools live on dedicated hosts; synthesis uses a shared workspace/socket with network disabled.
| From | To | Protocol / responsibility | Flow |
|---|---|---|---|
| Browser / Fleury CLI | Next.js dashboard | HTTPS | Request / response |
| Next.js dashboard | Identity service | OIDC | Request / response |
| Next.js dashboard | Go control plane | REST / OpenAPI | Request / response |
| Browser / Fleury CLI | Go control plane | CLI: direct API access | Request / response |
| Go control plane | PostgreSQL | SQL · product authority | Persistent data |
| Go control plane | Secrets store | Secret resolution | Control / operations |
| PostgreSQL | Command relay | Durable commands | Persistent data |
| Command relay | Temporal server | Workflow dispatch | Queued work |
| Temporal server | Go execution workers | Temporal task queues | Queued work |
| Go execution workers | Rust analyzers | Bounded analysis | Request / response |
| Go control plane | Object storage | Evidence API | Persistent data |
| Go control plane | Governed AI jobs | Policy-checked AI work | Queued work |
| Go execution workers | Runner control / agents | mTLS · commands / receipts | Request / response |
| Runner control / agents | Web / API / Mobile | Browser / API / device actions | Request / response |
| Go control plane | Test synthesis worker | Unix socket + shared workspace | Control / operations |
| Runner control / agents | Go control plane | Evidence receipts → control plane | Persistent data |
The event infrastructure transports durable facts into consumers and projections. Event transport, read models and observability are separate responsibilities from the control and execution plane.
Container and Kubernetes packaging define service roles, network boundaries, persistent storage, resource limits and scaling policies.
Docker Compose packages the dashboard, control plane, migrations, Temporal, relay, outbox/maintenance workers, PostgreSQL, object storage, identity and secrets services. Signed image bundles and volumes support offline installation and backup/restore.
The event plane connects change capture, an event broker, domain consumers and derived stores. Telemetry, trace storage, metrics and dashboards support diagnosis; product state remains owned by the control plane.
| From | To | Protocol / responsibility | Flow |
|---|---|---|---|
| Control-plane writers | PostgreSQL | SQL / transaction | Persistent data |
| PostgreSQL | Change data capture | WAL / logical replication | Events / callbacks |
| Change data capture | Event broker + schemas | CDC facts / schemas | Events / callbacks |
| Event broker + schemas | Go consumers / relays | Consume / project | Events / callbacks |
| Event broker + schemas | Temporal dispatch | Command events | Events / callbacks |
| Control-plane writers | Telemetry collector | Services → OTLP | Control / operations |
| Telemetry collector | Trace + metric storage | Traces / metrics | Control / operations |
| Observability dashboard | Trace + metric storage | Query | Request / response |
The control plane and PostgreSQL remain authoritative; event transport and derived projections do not silently replace product state.
Tests and exploration can run separately. Correlation requires matching source revisions, so a missing second run does not become fabricated coverage.
Durable commands, Temporal workflows and isolated runners preserve execution context across interruption and recovery.
AI proposes correlations, tests and briefs from bounded evidence. Review and actual execution determine what is accepted; the quality engine owns the release decision.
Choose a web application, API or mobile build and the relevant source revisions.
Launch an exploration or select supported test suites. Each workflow can run independently.
Track activity and inspect the states, transitions and evidence produced by the runners.
Inspect failures and evidence, ask the contextual assistant and review correlations or proposed tests.
Review the quality gate, validate follow-up tests and publish a stakeholder brief or shared decision.
Connect a target or repository, investigate real results, review AI-assisted follow-up work and communicate a release decision.
Discuss this Project