README.md

---
license: other
license_name: dax-1-research-license
library_name: llama.cpp
pipeline_tag: text-generation
base_model: Qwen/Qwen3-14B
tags:
  - gguf
  - spreadsheet
  - structured-output
  - tool-use
  - research-only
---

# 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:

```json
{
  "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:

```bash
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:

```bash
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:

```bash
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](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](THIRD_PARTY_NOTICES.md).

## Citation

```bibtex
 @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}
  }
```