Hugging Face's logo

theunnecessarythings
/
JADE

PEFT
Safetensors
English
decision-making
classification
tool-selection
lora
Model card Files
xet
 Community
JADE
File size: 4,180 Bytes
fdbed23
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
8e9f9a3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
fdbed23
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
---
license: apache-2.0
base_model: Qwen/Qwen3.8-27B
library_name: peft
language:
  - en
tags:
  - decision-making
  - classification
  - tool-selection
  - lora
---
# JADE

**Just Another Decision Engine.**

Give JADE some context, a question, and a set of options. It returns a decision
and a probability for each option. It can also answer yes/no questions with a
probability. There is no generated explanation to parse.

JADE is built on [Qwen3.8-27B](https://huggingface.co/Qwen/Qwen3.8-27B), with
rank-8 LoRA adapters and a trained 255-way decision head. This release was
trained on 160,017 synthetic examples covering reasoning, language,
classification, retrieval, tools, and probabilistic decisions.

## Using JADE

The included inference code uses Python 3.11+ and vLLM. You will need an NVIDIA GPU with enough
memory for the 27B base model and its inference cache. We tested this release
on a B200 with vLLM 0.30.0.

```bash
pip install vllm==0.30.0 huggingface_hub
hf download theunnecessarythings/JADE --local-dir ./jade-model
export PYTHONPATH="$PWD/jade-model:$PYTHONPATH"
```

```python
from jade import JadeEngine

engine = JadeEngine(model="./jade-model")

response, _ = engine(
    state="Move my meeting with Sam to tomorrow at 3 pm.",
    questions={
        "tool": {
            "type": "choice",
            "instructions": "Which tool should handle this request?",
            "criteria": {
                "calendar": "Find and update a calendar event",
                "email": "Search the email inbox",
                "notes": "Create a note",
            },
        }
    },
)

print(response["answers"]["tool"])
# Contains "choice" and a "probabilities" mapping for all three options.
```

For a yes/no question, use `"type": "noul"`. Its answer contains `"noul"`,
the probability of **yes**. You can supply several named questions in one call.

The engine supports text inputs, up to **255 options per question**, and
**8,192 tokens including the answer token**. Images and `score` questions are
not supported by this release. Inputs that exceed these limits raise an error.

## Training

JADE was trained on [JADE-Data](https://huggingface.co/datasets/theunnecessarythings/JADE-Data),
a synthetic corpus of 160,017 decision-making examples. Labels are derived from
programs, simulators, solvers, and structured world state.

| Setting | Value |
|---|---|
| Backbone | Qwen3.8-27B, BF16 |
| LoRA rank / alpha | 8 / 16 |
| Learning rate | 5e-5 |
| Effective batch size | 128 |
| Training | One epoch, 160,017 examples |
| Selected checkpoint | Step 1,251 |

A temperature of **0.288644** was fitted on a separate calibration partition.
The inference code applies it to every question.

## Evaluation

JADE scores **53.16 on Decision Index 0.2.1**, evaluated on the full suite with
[the official reproduction kit](https://github.com/apolinario/decision-index).

| Metric | Result |
|---|---:|
| Decision Index | **53.16** |
| Balanced raw | 64.52 |
| Breadth skill | 51.97 |
| Median latency | 100.3 ms |
| p95 latency | 716.9 ms |

| Area | Raw score | Chance-adjusted skill |
|---|---:|---:|
| Knowledge & reasoning | 52.67% | 40.71% |
| Language understanding | 71.15% | 57.62% |
| Retrieval & classification | 67.53% | 54.40% |
| Tools & automation | 76.02% | 73.18% |
| Arts & human taste | 51.00% | 34.76% |

Run on one **NVIDIA RTX PRO 6000 Blackwell**, using vLLM 0.30.0.
[Full results and predictions](https://huggingface.co/datasets/theunnecessarythings/JADE-Decision-Index).

To run the official suite, follow the
[Decision Index instructions](https://github.com/apolinario/decision-index).
After building and verifying the suite, use the included adapter:

```bash
python -m decision_index pipeline --edition 0.2.1 \
  --suite-dir /path/to/suite-0.2 \
  --engine jade.index:DecisionIndexEngine \
  --model "$PWD/jade-model" \
  --out runs/jade
```

## License

JADE is an independent model, not Jev, and is not affiliated with TypeSafe AI.
The weights and original release code are Apache-2.0. The prompt renderer is
adapted from [AutoJev](https://huggingface.co/denis-pplx/autojev-27b); its MIT
license is included in `LICENSE-AutoJev`.