---
license: apache-2.0
base_model: bespokelabs/Bespoke-Nimble-9B
library_name: peft
language:
- en
tags:
- lora
- classification
- agents
- decision
- nimble
---

> **Superseded by [Polaris 3](https://huggingface.co/damianborek/polaris-3) (`damianborek/polaris-3`) — seed average 77.1% vs 64.9% on real orchestrator packets (3-model labels). [Polaris 2](https://huggingface.co/damianborek/polaris-2) came in between.**

# Polaris 1

Polaris 1 (`polaris-1`) is the autonoxis decision model: a LoRA adapter for
[bespokelabs/Bespoke-Nimble-9B](https://huggingface.co/bespokelabs/Bespoke-Nimble-9B)
(revision `594dfdcfb6f94e3d0c0db7535180d3c71689169a`), itself built on Qwen3.5-9B.
It makes "conductor" decisions for autonomous coding agents. It does not generate text. Nimble scores the answer tokens and the adapter returns a
probability for each allowed label.

Two tracks, one question per request:

| track | labels |
|---|---|
| `decision`: what should the conductor do next with this lane? | `STOP`, `ASK`, `DISPATCH` |
| `manager`: what should happen to the evidence returned for this lane? | `ACCEPT`, `VERIFY`, `REJECT`, `REOPEN`, `ESCALATE` |

The question wording and the label criteria the adapter was trained on are in `conductor-questions.json`.
The adapter's `autonoxis.json` carries its name (`polaris-1`), which `autonoxis-server` reports.

This repository was previously named `damianborek/autonoxis-conductor-9b`; that URL redirects here.

## Links

- Polaris 3 model (latest, recommended): https://huggingface.co/damianborek/polaris-3
- Polaris 2 model (successor): https://huggingface.co/damianborek/polaris-2
- Vega 1 model (earlier, generative): https://huggingface.co/damianborek/vega-1
- Pi plugin + server: https://github.com/damian87x/pi-autonoxis-model
- Claude Code plugin: https://github.com/damian87x/autonoxis-model

## Use with the autonoxis plugins

The easiest way to use Polaris 1 is through the autonoxis server and one of its two clients: a Pi extension
and a Claude Code plugin. Both send the trained call convention for you, act only at confidence ≥ 0.8
(never lower: Pi uses a fixed 0.8; the Claude CLI `-t` can only raise it), reject a label that does not belong to the requested
track, and on any error (server down, bad response) return an error instead of a label, so nothing acts
and the decision goes to a stronger model or a human.

**1. Run the server.** `server.py` and its full setup (NVIDIA GPU, about 20 GB in bf16; torch, transformers,
peft, huggingface_hub) are in [pi-autonoxis-model/server](https://github.com/damian87x/pi-autonoxis-model/tree/main/server):

```bash
git clone https://github.com/damian87x/pi-autonoxis-model && cd pi-autonoxis-model
git clone https://github.com/bespokelabsai/nimble server/nimble
hf download bespokelabs/Bespoke-Nimble-9B --revision 594dfdcfb6f94e3d0c0db7535180d3c71689169a --local-dir base
hf download damianborek/polaris-1 --local-dir adapter
echo '{"model_path": "base", "max_input_tokens": 2048}' > nimble-model.json
python server/server.py --model-config nimble-model.json --adapter adapter --port 8765
```

It listens on `http://127.0.0.1:8765` (loopback only, no authentication). Both clients read `AUTONOXIS_URL`
and default to that address.

**2. Pi.**

```bash
pi install git:github.com/damian87x/pi-autonoxis-model
```

Tools: `autonoxis_conductor` (`{track: "decision" | "manager", packet}` → `label`, `confidence`,
`probabilities`, `act`) and `autonoxis_evaluate` (raw Jev `{state, questions}`). Command:
`/autonoxis-model status | test`.

**3. Claude Code.**

```
/plugin marketplace add damian87x/autonoxis-model
/plugin install autonoxis-model@autonoxis-model
```

(or `claude plugin marketplace add damian87x/autonoxis-model` and
`claude plugin install autonoxis-model@autonoxis-model` from a shell). Then
`/autonoxis-model:autonoxis status | decision <packet> | manager <packet>`, or the plugin's CLI directly:

```bash
python3 scripts/autonoxis.py conductor --track manager --file packet.txt
# exit 0 = ACT (conf >= 0.8), 3 = ESCALATE (below 0.8), 2 = error (never act)
```

**4. Raw HTTP.** One question with id `label`, state `{"packet": ...}`, and the `instructions` and `criteria`
for the track copied verbatim from `conductor-questions.json`:

```bash
curl -s http://127.0.0.1:8765/v1/systemone -H 'Content-Type: application/json' -d '{
  "state": {"packet": "Lane L3: add retry to the upload client. Tests pass on the branch. Reviewer approved. No open questions. Worker idle."},
  "questions": {"label": {
    "type": "choice",
    "instructions": "`packet` describes the current state of an automated engineering lane. What is the next externally visible conductor action? Prefer DISPATCH when a safe, authorized next dispatch exists; otherwise ASK when only the human can resolve it; otherwise STOP.",
    "criteria": {
      "STOP": "No useful automated dispatch is permitted under the current authority or packet. Halt and report the blocker.",
      "ASK": "A human decision, clarification, or additional authority is required before any useful dispatch.",
      "DISPATCH": "A bounded worker, verifier, reviewer, or QA action is permitted now, including dispatching fresh verification after rejecting stale evidence."
    }}}}'
```

Response:

```json
{"model": "polaris-1", "answers": {"label": {"type": "choice", "choice": "DISPATCH", "confidence": 1.0, "probabilities": {"STOP": 0.0, "ASK": 0.0, "DISPATCH": 1.0}}}, "usage": {"input_tokens": 308, "output_tokens": 0}, "server_ms": 486.9}
```

With raw HTTP, apply the 0.8 gate yourself.

## How to use

You need the Nimble prompt builder and scorer from [github.com/bespokelabsai/nimble](https://github.com/bespokelabsai/nimble):
`nimble.scoring.parallel_schema.prepare_prompts` and `nimble.training.schema_train.candidate_logits`.

The call convention matches training. Use it exactly:

- ask **one** question per request, with the field id `label`;
- the state is the JSON `{"packet": <packet text>}`;
- the field's description and choice descriptions come from `conductor-questions.json` (`instructions` and `criteria` for that track).

Load the base model and attach the adapter **unmerged**. `merge_and_unload()` in bf16 shifts the
probabilities: on one evaluation packet VERIFY went from 0.7278 unmerged to 0.6765 merged.

```python
import json, torch
from transformers import AutoTokenizer, AutoModelForImageTextToText
from peft import PeftModel
from huggingface_hub import hf_hub_download
from nimble.scoring.parallel_schema import prepare_prompts
from nimble.training.schema_train import candidate_logits

BASE, REV = "bespokelabs/Bespoke-Nimble-9B", "594dfdcfb6f94e3d0c0db7535180d3c71689169a"
ADAPTER = "damianborek/polaris-1"

tok = AutoTokenizer.from_pretrained(ADAPTER)
model = AutoModelForImageTextToText.from_pretrained(BASE, revision=REV, dtype=torch.bfloat16).to("cuda")
model = PeftModel.from_pretrained(model, ADAPTER).eval()   # do not merge
questions = json.load(open(hf_hub_download(ADAPTER, "conductor-questions.json")))

def ask(packet: str, track: str) -> dict:
    q = questions[track]
    field = {"type": "enum", "description": q["instructions"],
             "choices": list(q["criteria"]), "choice_descriptions": q["criteria"]}
    p = prepare_prompts(tok, json.dumps({"packet": packet}, ensure_ascii=False), {"label": field}, 2048)
    ids, cands = p.full_ids[0], p.candidate_ids[0]
    batch = {"input_ids": torch.tensor([ids], device="cuda"),
             "attention_mask": torch.ones(1, len(ids), dtype=torch.long, device="cuda"),
             "candidate_ids": torch.tensor([cands], device="cuda"),
             "candidate_mask": torch.ones(1, len(cands), dtype=torch.bool, device="cuda")}
    with torch.inference_mode(), torch.autocast("cuda", dtype=torch.bfloat16):
        probs = candidate_logits(model, batch)[0].double().softmax(-1).tolist()
    return dict(zip(q["criteria"], probs))

print(ask("Lane 3 returned a passing test run for commit abc123, but the lane head is now def456 ...", "manager"))
```

**Confidence gate.** Compute `conf = (n * max_prob - 1) / (n - 1)`, where `n` is the number of labels.
Act on the top label only when `conf >= 0.8`. Below that, escalate to a stronger model or a human.

A local HTTP server with a Jev-compatible request shape (`autonoxis-server`) exists and loads the adapter
unmerged in the same way. It is not part of this repository, and there is no public hosted endpoint.

## Training

- Recipe: LoRA r=16, alpha=32, dropout 0.05, on the language-model Linear layers (attention, linear-attention
  and MLP projections). Candidate cross-entropy over the answer tokens. lr 5e-5, effective batch 8, 3 epochs,
  linear schedule with 10% warmup, bf16.
- Data: 1076 rows. 316 come from lab history. The other 760 are drafted contrastive rows aimed at the hard
  boundaries (ASK/STOP, REJECT/ESCALATE, REJECT/REOPEN, VERIFY/REJECT). Label disagreements were adjudicated
  by Fable 5 (`claude-fable-5`). The 760 drafted rows are disjoint from every evaluation set (checked at
  build time).
- This adapter is seed 1 of a 10-seed run. It was chosen by a fixed rule that looks only at v5 and the
  all-seed ensemble.
- The training data is not released.

## Results

The gold labels are Fable 5 (`claude-fable-5`). "Unsafe" means the model predicted `DISPATCH` or `ACCEPT`
where the gold label is different. The evaluation sets are not released. `eval-summary.json` holds the
per-set metrics for this adapter (no packet text).

**v8 (60 rows) is the fair check.** It was never used for training or selection.

| | v8 |
|---|---|
| 10 seeds, mean ± sd | 59.2 ± 0.9 / 60 (min 58, max 60) |
| this adapter (seed 1) | 58 / 60 (decision 24/24, manager 34/36) |
| unsafe | 0 in every seed |
| this adapter, conf ≥ 0.8 | keeps 59, accuracy 0.983 |

This adapter misses two v8 packets: `v8_g04` REJECT→VERIFY (conf 0.66, below the gate) and `v8_g27`
ACCEPT→VERIFY (conf 0.998).

v8 is **in-distribution**. It shares 7 scenario families with the training data and came from the same
drafting pipeline. It is not an out-of-distribution test.

**v5 to v7 are not clean held-out sets.** Targeted training batches were written from the contract rules
the model misapplied on these sets. The scenarios are new and none of the eval wording was reused, but the
gains are partly driven by those errors. Reported for completeness only:

| | v5 | v6 | v7 |
|---|---|---|---|
| 10 seeds, mean ± sd | 39.9 ± 0.3 / 40 | 47.4 ± 0.5 / 48 | 47.9 ± 0.3 / 48 |
| this adapter | 40 / 40 | 48 / 48 | 48 / 48 |

**References on the same packets:**

- Untrained Jev (TypeSafe) also scores 60/60 on v8. This adapter does not beat Jev. Its value is that it
  runs locally and costs nothing per call. In a 3-request check on one local GPU, the two requests after
  warm-up took 97 and 111 ms each (the first request, which included CUDA warm-up, took 494 ms).
- Stock Bespoke-Nimble-9B without the adapter: v6 41/48 and v7 40/48, with 11 confident-but-wrong answers
  at conf ≥ 0.8.
- To check the labels, Opus 5.5 (`claude-opus-5-5`) re-labelled all 196 v5–v8 packets blind. It agreed with
  the Fable 5 gold on 194 of 196.

## Limitations

- Prompts are limited to 2048 tokens. Longer packets are rejected, not truncated.
- English only.
- Narrow domain: conductor and manager decisions for autonomous coding lanes, as defined by one decision
  contract. The labels reflect that contract's rules and will not transfer to other policies.
- The probabilities are not calibrated beyond the evaluation sets above. The 0.8 gate was only checked on
  those sets.
- The adapter is trained for the single-question convention above. Asking both questions in one schema
  changes some predictions.

## License

Apache-2.0, the same as the base model. Bespoke-Nimble-9B is itself a LoRA-merged Qwen/Qwen3.5-9B, which is
also Apache-2.0.