Dax-1

Dax-1 is a compact spreadsheet-editing model built to turn natural-language requests and workbook context into structured, executable patches. It is derived from Qwen3-14B and was recovered for seven spreadsheet task families before conversion to a single IQ3_S GGUF artifact.

This private repository distributes the standalone neural model for non-commercial research and evaluation. The adapter is already merged. A separate LoRA is not required.

Repository contents

File	Purpose
dax1-final.gguf	Standalone quantized model
SHA256SUMS	Integrity checksum for the GGUF
manifest.json	Machine-readable artifact metadata
LICENSE	Dax-1 Research License
THIRD_PARTY_NOTICES.md	Upstream attribution and license notices

The repository intentionally does not contain the production routing layer, private benchmark data, training data, a separate adapter, or full-precision weights.

Model details

Property	Value
Architecture	Qwen3-14B-derived causal language model
Format	GGUF
Quantization	IQ3_S
File size	6,788,274,816 bytes, 6.79 GB, 6.32 GiB
SHA-256	6cbb881a03aae833bd1e044b4cfc5d450376ab734f6c594361ee9a1a39d0a9c5
Adapter state	Merged before GGUF conversion
Recommended context	8,192 tokens
Output format	spreadsheet_edit_patch_v1 JSON
Evaluation decoding	Temperature 0, thinking disabled, one attempt
License	Non-commercial research and evaluation only

The exact artifact loaded at approximately 7,965 MiB in the recorded GPU evaluation environment. Allow at least 10 GB of VRAM for practical deployment headroom. CPU and partial-offload inference are possible through llama.cpp, with latency depending heavily on hardware and context length.

Intended tasks

Dax-1 was developed around seven bounded spreadsheet-editing families:

1. Aggregation
2. Date, filter, and sort repair
3. Duplicate removal
4. Formatting cleanup
5. Formula repair
6. Lookup and join repair
7. Row-deletion cleanup

In the production system, formula repair, lookup and join, formatting cleanup, and date, filter, and sort repair use the neural model path. Aggregation, duplicate removal, and row deletion use deterministic execution where exact indexing is more reliable. That deterministic layer is not included here.

Input and output contract

The model expects a user request together with enough workbook context to identify the relevant sheets, cells, ranges, formulas, and values. It should return a JSON patch instead of a rewritten workbook or a prose explanation.

A representative response has this shape:

{
  "patch_version": "spreadsheet_edit_patch_v1",
  "operations": [
    {
      "op": "set_cell",
      "sheet": "Invoice Computation",
      "cell": "D18",
      "formula": "=B18*C18",
      "number_format": "$#,##0.00"
    }
  ]
}

The principal patch operations are set_cell and set_range_values. A host application should parse and validate the JSON, verify sheet and range references, enforce operation allowlists, and review the patch before changing a workbook. Do not execute model output as arbitrary code.

Download

This is a private repository, so authenticate with an account that has access:

hf auth login
hf download trydecidedotai/Dax-1 \
  dax1-final.gguf SHA256SUMS \
  --local-dir ./Dax-1

cd Dax-1
sha256sum -c SHA256SUMS

On macOS, use shasum -a 256 dax1-final.gguf and compare it with the checksum listed above.

Run with llama.cpp

Use a current CUDA-enabled build of llama.cpp:

llama-server \
  -m ./Dax-1/dax1-final.gguf \
  -ngl 99 \
  -c 8192 \
  --host 127.0.0.1 \
  --port 8080

Example request using the OpenAI-compatible endpoint:

curl http://127.0.0.1:8080/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "dax1-final.gguf",
    "messages": [
      {
        "role": "user",
        "content": "Repair the missing total formula in D18 on Invoice Computation. Workbook context: B18=12, C18=24.50, D18 is blank. Return only spreadsheet_edit_patch_v1 JSON."
      }
    ],
    "temperature": 0,
    "max_tokens": 512,
    "chat_template_kwargs": {"enable_thinking": false}
  }'

For a network-facing service, place the server behind authentication, TLS, request-size limits, timeouts, and output validation. The command above binds to localhost by design.

How the artifact was produced

The release followed a behavior-first compression and recovery process:

1. Start from a Qwen3-14B-derived spreadsheet checkpoint.
2. Measure regressions by task family after compression.
3. Train focused recovery data for the damaged behaviors.
4. Merge the recovery adapter into the model weights.
5. Convert the merged checkpoint to F16 GGUF.
6. Quantize the converted model to IQ3_S.
7. Evaluate the exact final GGUF rather than a proxy checkpoint.

Candidate artifacts were selected through executable workbook behavior, not perplexity alone. Smaller candidates that failed the behavioral gate were not promoted. The final 6.79 GB artifact is approximately 77% smaller than the 29.5 GB-class merged checkpoint used before GGUF quantization.

Production evaluation

The public Dax-1 result is measured in the full production configuration, which combines this quantized neural model with a deterministic routing and execution layer. The frozen internal benchmark contains 350 tasks, with 50 tasks from each of the seven families.

Family	Strict workbook passes
Aggregation	42 / 50
Date, filter, and sort	40 / 50
Duplicate removal	50 / 50
Formatting cleanup	50 / 50
Formula repair	50 / 50
Lookup and join	40 / 50
Row deletion	49 / 50
Overall	321 / 350, 91.7%

Of the 350 tasks, 200 used the neural path and 150 used deterministic execution. The reported 321/350 score therefore belongs to the Dax-1 production system. It is not a standalone score for the lone GGUF in this repository, and the production result cannot be reproduced without the separate routing and execution components.

On a 70-task routed serving gate, the production configuration recorded:

• P50 latency: 1.48 seconds
• P95 latency: 2.42 seconds
• Errors: 0
• Maximum recorded route footprint: 7,613 MiB

These measurements describe the recorded evaluation environment and should not be treated as guarantees for other hardware, runtimes, prompts, or workbooks.

Evaluation protocol

Strict success required the produced patch to create the expected workbook state. Textual similarity alone did not count as a pass. Evaluation used:

• 350 frozen tasks, 50 per family
• Temperature 0
• Thinking disabled
• One generation attempt per task
• 8,192-token context
• Exact patch parsing and workbook execution
• Frozen benchmark SHA-256: 31d5c5eaef4d6efc96e6632c1bba5a188c6c0e707cf256e45aeb95638c6be6bd

The benchmark is internal and is not included in this repository. Results should be interpreted as evidence on this bounded evaluation, not as a claim of universal spreadsheet competence.

Limitations

• Dax-1 is specialized for the seven task families above.
• Arbitrary workbook schemas, macros, charts, pivot tables, external data connections, and cross-workbook workflows are not comprehensively covered.
• Long, ambiguous, or incomplete workbook context can lead to incorrect cell references or invalid patches.
• Exact arithmetic, localization, date conventions, and formula dialects can vary between spreadsheet applications.
• Quantization can change behavior relative to a higher-precision checkpoint.
• Model output must be validated before it is applied to valuable workbooks.
• The production routing and deterministic execution layer is not released in this repository.

License

Dax-1 is available for non-commercial research and evaluation only under the Dax-1 Research License. Commercial use, production deployment, paid access, and commercial derivatives are prohibited without separate written permission from Decide.

Dax-1 is derived from Qwen3-14B. The upstream Qwen components remain subject to the Apache License 2.0. See THIRD_PARTY_NOTICES.md.

Citation

 @techreport{decide2026dax1,
    title       = {Dax-1: Efficient, Executable Spreadsheet Editing},
    author      = {{Decide Research Team}: Abiodun Adetona and Al-ameen Olajide},
    institution = {Decide},
    year        = {2026},
    month       = {August},
    type        = {Technical Report}
  }