~/thinkingdbx/bonacci-moe-9b
thinkingdbx / bonacci moe 9b
data engineering model · under build
under active development · coming soon

Bonacci MoE 9B

The first purpose-built mixture-of-experts model for Data Engineering & Data Science. Expert-level SQL generation, PySpark pipeline authoring, data modeling, and autonomous multi-step orchestration — all in a single 9B sparse model that activates only 2.6B parameters per token.

explore architecture ↓
9B
total params
2.6B
active / token
32K
context
14
capabilities
architecture
Sparse MoE, densely capable

8 experts per layer, top-2 routing, GQA attention. Only 2.6B of 9B parameters fire per token — frontier-class quality at small-model cost.

Model Parameters

Model typeSparse MoE
Total parameters9B
Active parameters2.6B / token
Experts per layer8
Expert routingTop-2
Context window32,768
Vocabulary49,152
LicenseCommercial

Transformer Block

Hidden dimension2048
Layers32
Attention heads16
KV heads (GQA)4
MLP dim / expert5504
Positional encodingRoPE
NormalizationRMSNorm
ActivationSwiGLU
14 native capabilities
Built for data work

Not a general-purpose code model bolted onto data tasks. Every capability is post-trained against execution-grounded rewards.

  1. 01

    SQL Generation & Optimization

    Production SQL from natural language. Optimize slow queries, explain execution behavior.

  2. 02

    SQL Dialect Translation

    BigQuery, Snowflake, Spark SQL, PostgreSQL, Trino — full semantic preservation.

  3. 03

    PySpark Pipeline Authoring

    Optimized batch & streaming pipelines with best-practice patterns built-in.

  4. 04

    ThinkingLanguage Native

    First-class understanding of the Bonacci platform's declarative pipeline DSL.

  5. 05

    Pipeline Autopilot

    Autonomous multi-step reasoning. Decompose, plan, iterate with execution feedback.

  6. 06

    Execution Plan Generation

    Structured JSON plans with cost estimates & optimization recommendations.

  7. 07

    Data Security

    PII detection, encryption strategy, RLS policies, GDPR/CCPA/HIPAA gap analysis.

  8. 08

    Data Modeling

    Star schema, Data Vault 2.0, Medallion, SCD Types 1/2/3/4.

  9. 09

    Lakehouse Integration

    Native knowledge of Apache Iceberg, Delta Lake, and Apache Hudi internals.

  10. 10

    Tool Use & MCP

    10+ tools via Model Context Protocol — DBs, storage, orchestration, catalogs.

  11. 11

    RAG-Aware Generation

    Consumes schema docs, table samples, and domain glossaries via the embedding model.

  12. 12

    Extended Thinking

    Surfaces multi-step reasoning for complex query & schema design decisions.

  13. 13

    DQ & Observability

    Data quality rules, freshness monitors, anomaly detection logic.

  14. 14

    Streaming & CDC

    Kafka, Flink, and CDC pipeline design with backward-compat checks.

in practice
See it work
sql · translation

Snowflake → BigQuery

Round-trip translation with full semantic preservation across five dialects: BigQuery, Snowflake, Spark SQL, PostgreSQL, Trino. Handles QUALIFY, OBJECT_CONSTRUCT, LISTAGG, window functions, and dialect-specific types.

  • Function-level dialect mapping
  • Window function rewrites
  • Type coercion safety
-- Snowflake (input): SELECT DATEADD(day, -30, CURRENT_TIMESTAMP()) AS ago, OBJECT_CONSTRUCT('k', col1, 'v', col2) AS j, LISTAGG(item, ',') WITHIN GROUP (ORDER BY item) AS items FROM my_table QUALIFY ROW_NUMBER() OVER (PARTITION BY id ORDER BY ts DESC) = 1; -- BigQuery (output): SELECT TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 30 DAY) AS ago, JSON_OBJECT('k', col1, 'v', col2) AS j, STRING_AGG(item, ',' ORDER BY item) AS items FROM ( SELECT *, ROW_NUMBER() OVER (PARTITION BY id ORDER BY ts DESC) AS rn FROM my_table ) WHERE rn = 1;
pipeline · autopilot

Autonomous multi-step reasoning

Give the model a high-level goal — "monitor Postgres CDC, detect schema drift, alert on anomalies, sync to Snowflake" — and it decomposes the task, generates a plan, and emits the full pipeline.

  • Decomposition & planning
  • Execution-feedback iteration
  • End-to-end YAML emission
User: "Build a pipeline that monitors Postgres CDC, detects schema drift, alerts on anomalies, and syncs to Snowflake" Step 1/6 [ Plan ] • Source: Postgres WAL via Debezium • Schema registry: Confluent • Drift detection: Avro schema diff • Anomaly: null rate + cardinality • Alert: Slack + PagerDuty • Target: Snowpipe Streaming Step 2/6 CDC source connector... Step 3/6 Schema drift logic... Step 4/6 12 statistical checks generated... Step 5/6 Alert routing with severity tiers... Step 6/6 MERGE statement + SCD Type 2... ✓ Pipeline complete — 847 lines emitted. $ bonacci deploy --pipeline cdc_snowflake_sync
thinkinglanguage · native

Declarative Bonacci pipelines

The model has first-class understanding of ThinkingLanguage — the Bonacci platform's declarative pipeline DSL. It composes sources, transforms, and sinks with awareness of the execution model.

  • Source / transform / sink composition
  • Dependency & schedule awareness
  • Multi-sink fan-out (warehouse + feature store)
pipeline: customer_ltv_360 schedule: "0 3 * * *" sources: - id: orders type: jdbc query: "SELECT * FROM orders WHERE updated_at > {{ last_run }}" transforms: - id: compute_ltv type: sql dialect: spark sql: | SELECT c.customer_id, SUM(o.total_amount) AS ltv FROM customers c LEFT JOIN orders o USING (customer_id) GROUP BY c.customer_id sinks: - type: bigquery write_mode: merge - type: redis key_template: "ltv:{customer_id}"
training
122B+ tokens, execution-grounded

Two-stage pre-training on TPU v6e-16 with MaxText/JAX, followed by SFT and GRPO with code-execution rewards.

  1. 01
    pre-train · stage 1 · 32B tokens

    General Corpus

    Broad language understanding, code, and reasoning foundations.

  2. 02
    pre-train · stage 2 · 90B tokens

    FineWeb-Edu

    High-quality educational and technical web content.

  3. 03
    post-train · sft · 15K+ pairs

    Supervised Fine-Tuning

    Curated DE/DS pairs — SQL, PySpark, ThinkingLanguage, pipeline blueprints, schemas.

  4. 04
    post-train · rl · 230 test cases

    GRPO + Code Execution

    Reward-shaped on SQL correctness, query plan quality, and PySpark execution — evaluated across 230 test cases across 6 benchmarks.

hardware
TPU v6e-16
Google Cloud
framework
MaxText / JAX
FSDP parallelism
long context
32K · YaRN
RoPE scaling extension
deployment
Run it anywhere

Safetensors, GGUF quantizations, OpenAI-compatible vLLM, Ollama, llama.cpp, and Docker.

🤗 HuggingFace ⚡ vLLM 🦙 Ollama 🐳 Docker 📦 llama.cpp · GGUF
vLLM · production

OpenAI-compatible API

$ vllm serve thinkingdbx/bonacci-moe-9b \ --dtype bfloat16 \ --max-model-len 32768 \ --tensor-parallel-size 2 \ --gpu-memory-utilization 0.90 # Query via OpenAI-compatible endpoint $ curl http://localhost:8000/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ "model": "thinkingdbx/bonacci-moe-9b", "messages": [{"role":"user","content":"..."}], "temperature": 0.1 }'
huggingface · transformers

Python (bfloat16)

from transformers import AutoModelForCausalLM, AutoTokenizer import torch model_id = "thinkingdbx/bonacci-moe-9b" tokenizer = AutoTokenizer.from_pretrained(model_id) model = AutoModelForCausalLM.from_pretrained( model_id, torch_dtype=torch.bfloat16, device_map="auto", ) messages = [ {"role": "user", "content": "Optimize this BigQuery..."}, ] inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device) outputs = model.generate(inputs, max_new_tokens=1024, temperature=0.1)
the bonacci platform
Where the model lives

Bonacci MoE 9B is the intelligence layer powering Bonacci Studio and Bonacci Flow.

bonacci · studio

Bonacci Studio

Conversational data engineering. Chat with the model, get production SQL, PySpark, and ThinkingLanguage pipelines back.

▸ explore studio →
bonacci · flow

Bonacci Flow

Pipeline Autopilot at platform scale — autonomous orchestration, scheduling, and self-healing for your data infrastructure.

▸ explore flow →
get started

Bonacci MoE 9B is coming soon

The model is currently under active development. Leave us a note and we'll let you know the moment weights and APIs are available — on HuggingFace, vLLM, and embedded inside the Bonacci platform.

try bonacci platform contact sales
in active development commercial license (planned) self-hostable (planned)

— first DE/DS-native MoE ✎