jinflow.io
Pluggable.
Philosophical.
Powerful.
A diagnostic analytics platform
that learns every domain it enters.
The Problem
Every organisation reconciles.
Almost none of them do it well.
Almost none of them do it well.
Multiple source systems. Manual spreadsheets. Tribal knowledge.
The person who knows what “normal” looks like retires or changes roles.
Every new domain, every new industry — the same six-month discovery.
The tooling doesn't transfer. The expertise doesn't accumulate.
The Vision
What if the platform learned
from every domain it entered?
- An engine that knows how to ingest, validate, diagnose, and present — for any domain.
- Domain packs that encode what to look for and why — all declarative, all swappable.
- AI that brings subject matter expertise on demand — new domain, new conversation.
- A compound effect where each deployment makes the next one faster and richer.
jinflow
Part I
The Platform
Three phases. Three stores. One continuous cycle.
The Cycle
Make. Explore. Evolve.
Make
Compile artifacts.
Build the database.
Validate everything.
Build the database.
Validate everything.
→
Explore
See the findings.
Understand patterns.
Ask new questions.
Understand patterns.
Ask new questions.
→
Evolve
AI-assisted refinement.
Author new diagnostics.
Capture knowledge.
Author new diagnostics.
Capture knowledge.
Evolve feeds back into Make. The cycle never ends.
Each turn produces a richer, more accurate analytical system.
Phase 1
jinflow make
The Builder
UI-less processing engine. Pure transformation.
Takes artifacts (CSVs, YAML definitions, contracts)
and produces a built DuckDB — the Knowledge Store.
Six compilers: probes, hypotheses, diagnoses,
SMEbits, BitBundles, registry.
Takes artifacts (CSVs, YAML definitions, contracts)
and produces a built DuckDB — the Knowledge Store.
Six compilers: probes, hypotheses, diagnoses,
SMEbits, BitBundles, registry.
jinflow make --tenant acme.warehouse_east
Key Properties
No UI. No interactivity. No AI.
Workspace isolation. Never mutates source files.
Deterministic. Same artifacts in → same database out.
Deployable anywhere. Laptop, CI, cloud function.
Multi-tenant. Each tenant is an isolated DuckDB schema.
Workspace isolation. Never mutates source files.
Deterministic. Same artifacts in → same database out.
Deployable anywhere. Laptop, CI, cloud function.
Multi-tenant. Each tenant is an isolated DuckDB schema.
Phase 2
jinflow explore
The Explorer
Visual application for the analytical database.
Browse dimensions, taxonomy hierarchies,
probe findings, hypothesis verdicts,
diagnosis root causes, expert knowledge.
Human-readable interpretations.
Multi-lingual (EN/DE/FR).
Browse dimensions, taxonomy hierarchies,
probe findings, hypothesis verdicts,
diagnosis root causes, expert knowledge.
Human-readable interpretations.
Multi-lingual (EN/DE/FR).
Key Properties
Read-only. Never writes to the database.
No AI. Human exploration, human insight.
Desktop or web. macOS, Linux, Windows, browser.
Any DuckDB. Point it at any Knowledge Store.
Locale switching. Same data, different language.
No AI. Human exploration, human insight.
Desktop or web. macOS, Linux, Windows, browser.
Any DuckDB. Point it at any Knowledge Store.
Locale switching. Same data, different language.
Phase 3
jinflow evolve
The Evolver
AI-powered REPL that closes the cycle.
Queries what make built.
Understands what explore revealed.
Authors the next generation of artifacts.
“Which entities drive the anomaly?”
“Write a probe for that pattern.”
Queries what make built.
Understands what explore revealed.
Authors the next generation of artifacts.
“Which entities drive the anomaly?”
“Write a probe for that pattern.”
Key Properties
The only tool with AI. Claude as co-pilot.
Reads the database. Writes artifacts.
Suggest, validate, compile. Full authoring workflow.
Human confirms. AI proposes, human approves.
Tenant-isolated. AI sees only the assigned tenant.
Reads the database. Writes artifacts.
Suggest, validate, compile. Full authoring workflow.
Human confirms. AI proposes, human approves.
Tenant-isolated. AI sees only the assigned tenant.
The Loop
Evolve writes artifacts.
Make builds them. Explore reveals what changed.
Evolve
new probe YAML
new probe YAML
→
Make
compile + build
compile + build
→
Explore
see new findings
see new findings
→
Evolve
refine thresholds
refine thresholds
→
…
Every turn through the cycle refines understanding.
The system gets smarter because the artifacts get better.
jinflow
Part II
The Architecture
Three stores. Compilers. The analytical pyramid.
Three Stores
Every piece of state has a home
AFS
Artifact Store
Git
All domain content.
CSVs, YAML definitions,
contracts, tenant configs.
Version-controlled.
Separate from engine code.
CSVs, YAML definitions,
contracts, tenant configs.
Version-controlled.
Separate from engine code.
KLS
Knowledge Store
DuckDB
The analytical database.
Built product of make.
Medallion layers, findings,
verdicts, expert knowledge.
Read-only for explore & evolve.
Built product of make.
Medallion layers, findings,
verdicts, expert knowledge.
Read-only for explore & evolve.
SIS
System Information Store
DuckDB
Operational state.
Build journal, instrument
lifecycle, compilation logs.
Strictly optional.
Everything works without it.
Build journal, instrument
lifecycle, compilation logs.
Strictly optional.
Everything works without it.
Who Touches What
Clear ownership. No ambiguity.
AFS
artifacts
artifacts
→
make
reads AFS
writes KLS
reads AFS
writes KLS
→
KLS
database
database
→
explore
reads KLS
reads KLS
KLS
database
database
→
evolve
reads KLS
writes AFS
reads KLS
writes AFS
→
AFS
artifacts
artifacts
→
make
rebuilds
rebuilds
AFS is the input to make. KLS is the output.
Evolve reads the output and writes the input. The cycle closes.
The Pipeline
Medallion architecture with a diagnostic layer
Source CSVs
any ERP export
any ERP export
→
Bronze
structural ingestion
structural ingestion
→
Silver
validated + typed
validated + typed
→
Gold
consumption contract
consumption contract
→
Diagnostics
probes + verdicts
probes + verdicts
Bronze = structure. Silver = domain truth. Gold = consumption contract.
No silent filtering — invalid rows are flagged, not dropped, until Gold.
Source-system dispatch happens only in Bronze.
From Silver onward, everything is source-system agnostic.
The Compilers
YAML in. SQL out. Six compilers.
P
Probes
Diagnostic queries on Gold entities. Balance, duplicate, trend, outlier, ratio, temporal, assessment. Produce standardised findings tables.
H
Hypotheses
Business questions evaluated against probe evidence. Weighted evidence chains produce verdicts: confirmed, plausible, not observed.
D
Diagnoses
Root cause explanations for confirmed hypotheses. Conditions, confidence scoring, structured recommendations.
S
SMEbits
Atomic expert knowledge. Free-floating. Optional executable checks. Attributed to a provider with scope and lifecycle.
B
BitBundles
Curated narrative groupings of SMEbits. The “story” layer. Metadata-only — no SQL, no computation.
R
Registry
Tri-lingual metadata for all instruments. Auto-generated from YAML + glossary. Human-readable display text.
The Analytical Pyramid
From data signals to root causes
Probes & Assessments
Technical findings. “Usage exceeds billing by 40%.”
Hypotheses
Business questions. “Revenue leakage from unbilled materials.”
Diagnoses
Root causes. “Billing workflow gap in surgical departments.”
Each layer adds interpretation and business context.
SMEbits float alongside — expert knowledge anchored anywhere.
Multi-Tenant
Every tenant is an isolated world
- Schema isolation. Each tenant is a DuckDB schema. Resettable independently. No data leakage.
- Source-system dispatch. Same domain pack handles multiple ERPs. Column mapping happens once, in Bronze.
- Platform layer. UNION ALL across tenants for cross-tenant analytics. Opt-in.
- AI isolation. When AI assists (evolve), it sees only its assigned tenant. Never cross-schema.
- Snapshot. Freeze any tenant's state as an immutable, self-describing DuckDB file. Audit-ready.
jinflow
Part III
Domain Packs
The pluggable expertise layer.
The Split
The engine doesn't know what an “invoice” is.
The domain pack does.
Engine (80%)
Medallion pipeline (Bronze → Silver → Gold)
Six YAML → SQL compilers
Findings contract (10 standard columns)
Taxonomy engine (tree + closure table)
Explorer (discovery, interpretation, i18n)
Multi-tenant platform layer
Orchestration + rebuild scripts
Knows how. Knows nothing about why.
Six YAML → SQL compilers
Findings contract (10 standard columns)
Taxonomy engine (tree + closure table)
Explorer (discovery, interpretation, i18n)
Multi-tenant platform layer
Orchestration + rebuild scripts
Knows how. Knows nothing about why.
Domain Pack (20%)
Gold contract (entity schemas)
Source-system dispatch (column mappings)
Probe YAML definitions (business rules)
Hypothesis + Diagnosis YAMLs
SMEbits + BitBundles
Registry (tri-lingual display text)
Interpretation rules
Knows why. All declarative. All swappable.
Source-system dispatch (column mappings)
Probe YAML definitions (business rules)
Hypothesis + Diagnosis YAMLs
SMEbits + BitBundles
Registry (tri-lingual display text)
Interpretation rules
Knows why. All declarative. All swappable.
Inside the Pack
A directory. YAML and JSON. No code.
packs/
domain-name/
domain-name/
→
contracts/
entity schemas
entity schemas
+
probes/
diagnostic rules
diagnostic rules
+
hypotheses/
business questions
business questions
+
glossary/
i18n + registry
i18n + registry
Self-contained. Versioned. Declarative.
The engine discovers and loads it via a manifest file.
Swap the directory → swap the domain.
What Transfers
The diagnostic patterns are universal
- Balance probes — compare two aggregates per entity. Usage vs billing. Received vs sold. Ordered vs delivered.
- Duplicate detection — same shape everywhere. Duplicate invoices, duplicate shipments, duplicate purchase orders.
- Trend analysis — rolling average drift. Material costs, lead times, defect rates. The math is identical.
- Mandatory item — “this entity must have that child.” Safety cert with equipment. Inspection with asset. Signature with contract.
- Taxonomy hierarchies — cost centres, product categories, regional structures. Same closure table, different labels.
Same Shape, Different Words
Probe types across domains
| Probe Type | Healthcare | Retail | Manufacturing |
|---|---|---|---|
| balance | Usage vs billed | Received vs sold | BOM vs actual |
| mandatory_item | Implant with surgery | Core assortment | QC cert with batch |
| trend | Cost drift per month | Margin erosion | Scrap rate trend |
| distribution_outlier | Case cost outlier | Return rate anomaly | Yield deviation |
| duplicate | Duplicate billing | Duplicate invoice | Duplicate shipment |
| assessment | Case integrity | Store health | Line efficiency |
The compiler generates identical SQL structures.
Only the entity names and thresholds change.
Where It Fits
Material/resource flows + financial reconciliation
Healthcare
Cases, procedures, materials, billing
Revenue leakage, compliance gaps, cost outliers
Manufacturing
Work orders, BOMs, inventory, shipments
Phantom consumption, BOM variance, scrap anomalies
Pharma & Life Sciences
Batches, formulations, QC results, distribution
Yield deviation, expiry risk, recall traceability
Retail & Warehouse
Purchase orders, stock movements, sales, returns
Shrinkage detection, dead stock, delivery anomalies
Public Sector Procurement
Tenders, contracts, invoices, deliveries
Duplicate invoicing, contract compliance, budget overruns
Construction
Projects, material requisitions, deliveries, invoices
Material waste, subcontractor billing anomalies
jinflow
Part IV
AI as Subject Matter Expert
The framework is the engineering. AI is the domain knowledge.
What AI Brings
Three roles, not one
1
Domain Pack Author
AI knows ERP schemas, business logic, regulatory context. It writes the YAML. A human reviews and approves. Weeks, not months.
2
Interactive Analyst
In the evolve phase, AI queries the Knowledge Store, interprets findings, suggests new probes and hypotheses. The human stays in the loop.
3
Knowledge Capturer
AI helps encode SMEbits — turning hallway conversations and expert intuition into structured, attributed, version-controlled artifacts.
The Scale Insight
New domain = new conversation.
Same framework.
jinflow
engine
engine
+
AI SME
domain knowledge
domain knowledge
→
Domain Pack
contracts + probes + i18n
contracts + probes + i18n
→
Running
Instance
Instance
To enter retail: ask AI about inventory schemas, shrinkage patterns,
planogram compliance, margin erosion — generate the domain pack.
To enter pharma: ask AI about batch records, LIMS formats,
yield calculations, GMP compliance — generate the domain pack.
The framework stays. The expertise is injected.
The Compound Effect
Each domain pack makes the platform
smarter for the next one.
- Domain 1 reveals that balance probes need interpretation rules — context-dependent severity. The engine gains the interpretation layer.
- Domain 2 reveals that trend probes need seasonal adjustment. The DSL gains a
seasonalmodifier. All domains benefit. - Each domain's calibrated thresholds inform the next. “What does normal look like?” gets answered by data, not guesswork.
- AI accumulates cross-domain patterns. The framework gets better at every domain because it's been to others.
jinflow
Part V
The Business
Open engine. Expert domain packs. AI-powered growth.
The Model
Three revenue layers
jinflow Engine
Pipeline, compilers, Explorer shell.
Open or source-available.
Drives adoption and trust.
The platform. Free to evaluate.
Open or source-available.
Drives adoption and trust.
The platform. Free to evaluate.
Domain Packs
Diagnostic rules, interpretation,
regulatory context, calibrated thresholds.
Subscription per tenant.
The expertise. The revenue.
regulatory context, calibrated thresholds.
Subscription per tenant.
The expertise. The revenue.
Custom Domains
Consulting engagement to build
a domain pack for a new industry.
AI-accelerated. Weeks, not months.
The growth engine.
a domain pack for a new industry.
AI-accelerated. Weeks, not months.
The growth engine.
The Moat
Four layers of defensibility
- Regulatory knowledge. Every domain has its legal landscape. The domain pack encodes it. Not easily reproduced.
- Calibrated thresholds. What does “normal” look like? You can't guess this. You earn it from production data.
- Interpretation rules. The difference between noise and signal. Context-dependent severity that turns raw findings into actionable insight.
- Source-system expertise. Every ERP has quirks. Column naming conventions, edge cases, undocumented behaviors. Earned through ingestion, not documentation.
Design Principles
What jinflow believes
- Domain agnosticism. jinflow knows about artifacts, compilers, tenants, and layers — not about invoices, batches, or shipments.
- Engine / content separation. The engine ships as a versioned package. Domain content lives in a separate git repo — the AFS.
- DuckDB as the universal contract. Make writes it. Explore reads it. Evolve queries it. No other shared state.
- Workspace isolation. Make never mutates source directories. Temp workspace → compile → build → output.
- Cloud readiness. Same Python library locally and in Lambda. Different callers, same engine.
Tech Stack
Boring where it matters. Sharp where it counts.
DuckDB
Knowledge Store
analytical database
analytical database
dbt
transformation layer
SQL models + tests
SQL models + tests
Python
engine + CLI
compilers + validators
compilers + validators
SvelteKit
Explorer frontend
desktop + web
desktop + web
Claude
AI backbone
evolve + authoring
evolve + authoring
jinflow.io
The framework
that learns every domain
it enters.
Highly automated. Deeply interactive.
AI brings the expertise. The engine makes it actionable.
Each deployment makes the next one faster.
Pluggable. Philosophical. Powerful.
jinflow
jinflow.io