polaris-1

Superseded by Polaris 3 (damianborek/polaris-3) — seed average 77.1% vs 64.9% on real orchestrator packets (3-model labels). Polaris 2 came in between.

Polaris 1

Polaris 1 (polaris-1) is the autonoxis decision model: a LoRA adapter for 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:

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:

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.

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:

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:

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:

{"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: 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.

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.

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:

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.