Skip to content

IxQL

Jump to bottom
Stephane Pareilleux edited this page Mar 22, 2026 · 1 revision

IxQL — ML Pipeline & Reactive Data Flow Language

IxQL is a declarative language for composing ML pipelines, MCP orchestrations, and reactive data flows. Defined as an EBNF grammar and executed by the ix forge.

Full guide: docs/ixql-guide.md

Quick Start

-- Simple classification pipeline
csv → normalize → random_forest → f1_score

Every IxQL pipeline is a governed artifact — constitutional gates can be inserted at any stage, and conclusions map to tetravalent logic (T/F/U/C).

Grammar Structure (11 Sections)

Section What It Covers
1. Pipeline Architecture Composition, ensembles
2. Data Sources CSV, JSON, Parquet, API, streaming, governance state, git history, MCP
3. Preprocessing Cleaning, transformation, feature engineering, splitting
4. Models Supervised, unsupervised, probabilistic, neural, reinforcement
5. Evaluation Metrics, validation strategies, interpretation (SHAP, LIME)
6. Deployment Serialization, serving, monitoring, drift detection
7. Governance Integration Bias assessment, reversibility, confidence calibration, explanation
8. ix-Specific Patterns Karnaugh, memristive Markov, grammar weights, compounding
9. I/O & Reactive Patterns WebSocket, file watcher, SSE, webhook, cron, message queues, flow control
10. MCP Orchestration Tool invocation, parallel tools, tetravalent gates, bindings, compound phases
11. Evolution Hooks Research cycles, distillation, external grammar consumption

Core Pipelines (7)

The 7 IxQL pipelines in pipelines/ are the backbone of Demerzel's automation:

Pipeline Purpose Trigger
conscience-cycle.ixql Daily conscience processing and digest generation Cron, 22:00 UTC
driver-cycle.ixql Autonomous development driver — full cycle across repos /demerzel-drive
governance-audit.ixql Weekly three-tier governance validation Cron, Sun 06:00 UTC
metasync.ixql Documentation drift detection and repair Push to master; Monday cron
research-cycle.ixql Seldon Plan — autonomous research and course production Cron, every 4h
weakness-probe.ixql Adversarial governance testing Weekly / on demand
ml-feedback-loop.ixql ix calibration signals → Demerzel belief updates ix pipeline complete

Use Cases

1. Research Pipeline

-- Guitar studies: Is CAGED geometry learnable in 3 sessions?
department_state("guitar-studies")
  → question_generation("caged-learnability")
  → cross_model_validation(
       claude.research(question),
       gpt4o.research(question)
     )
  → evaluation(agreement_score, evidence_density)
  → when T >= 0.8: course_production("GTR-003", languages: ["en", "es", "fr"])
  → compound:
      harvest findings
      promote if T >= 0.9
      teach to seldon

2. Governed ML Ensemble

-- Governance health scoring with bias checks
(governance_state → cleaning(missing: drop) → gradient_boosting → f1_score)
  + (governance_state → embedding("governance") → transformer → auc_roc)
  => stacking
  → bias_assessment          -- Article 10: Stakeholder Pluralism
  → confidence_calibration
  → explanation_requirement  -- Article 2: Transparency
  → when T >= 0.7: mcp_tool_integration("governance-health-scorer")

3. Reactive Governance

-- Watch beliefs for drift, alert if confidence drops
watch("state/beliefs/*.json")
  → debounce(5s)
  → governance_state
  → drift_detection
  → filter(drift_score > 0.3)
  → alert(discord, "Belief drift detected: {{belief.name}}")

-- GitHub push triggers 3 parallel governance checks
webhook(github, "push")
  → fan_out(
      recon_pipeline,
      staleness_check,
      readme_sync
    )
  → when any_failed: alert(discord, "Governance check failed: {{failed_checks}}")

4. MCP Orchestration

-- Multi-repo analysis: resolve docs, analyze, train
result <- context7.resolve("react")
  → when T >= 0.8: analysis <- tars.analyze(result)
  → when T >= 0.7: features <- ix.ml.extract_features(analysis)
  → ix.ml.train(features, model: "gradient_boosting")
  → evaluation(f1_score, shap_values)
  → when T >= 0.9: mcp_register("react-analyzer", "Analyzes React codebases")

-- Parallel tool fanout with merge
parallel(
  tars.grammar.parse(input),
  ix.ml.classify(input),
  context7.query("react", input)
) → merge_results
  → when T >= 0.7: output

Key Operators

Operator Meaning
→ Pipe: pass output of left to input of right
+ Ensemble: combine parallel models
=> Merge strategy: ensemble → single model
← Bind: assign result to variable
when T >= 0.8: Tetravalent gate: only continue if condition met
fan_out(...) Parallel execution of multiple branches
parallel(...) Concurrent tool calls, merge at end
watch(...) Reactive: trigger on file/event changes
cron(...) Scheduled: trigger on time pattern
webhook(...) Event-driven: trigger on external event
compound: Post-processing: harvest, promote, teach

Governance Integration

IxQL pipelines are constitutional artifacts:

  • Constitutional gates can be inserted between any two stages
  • Conclusions map to tetravalent logic (T/F/U/C)
  • All pipeline runs are logged for auditability (Article 7)
  • when gates enforce bounded autonomy (Article 9)
  • Bias assessment stages enforce stakeholder pluralism (Article 10)

Related Pages

Clone this wiki locally