Instructions to use imgovind/wrightproduct-v0-lora with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use imgovind/wrightproduct-v0-lora with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="imgovind/wrightproduct-v0-lora")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoModel
model = AutoModel.from_pretrained("imgovind/wrightproduct-v0-lora", device_map="auto")

MLX

How to use imgovind/wrightproduct-v0-lora with MLX:

# Make sure mlx-lm is installed
# pip install --upgrade mlx-lm

# Generate text with mlx-lm
from mlx_lm import load, generate

model, tokenizer = load("imgovind/wrightproduct-v0-lora")

prompt = "Write a story about Einstein"
messages = [{"role": "user", "content": prompt}]
prompt = tokenizer.apply_chat_template(
    messages, add_generation_prompt=True
)

text = generate(model, tokenizer, prompt=prompt, verbose=True)

Notebooks
Google Colab
Kaggle
Local Apps Settings
LM Studio

vLLM

How to use imgovind/wrightproduct-v0-lora with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "imgovind/wrightproduct-v0-lora"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "imgovind/wrightproduct-v0-lora",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/imgovind/wrightproduct-v0-lora

SGLang

How to use imgovind/wrightproduct-v0-lora with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "imgovind/wrightproduct-v0-lora" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "imgovind/wrightproduct-v0-lora",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "imgovind/wrightproduct-v0-lora" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "imgovind/wrightproduct-v0-lora",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

How to use imgovind/wrightproduct-v0-lora with Pi:

Start the MLX server

# Install MLX LM:
uv tool install mlx-lm
# Start a local OpenAI-compatible server:
mlx_lm.server --model "imgovind/wrightproduct-v0-lora"

Configure the model in Pi

# Install Pi:
npm install -g @earendil-works/pi-coding-agent
# Add to ~/.pi/agent/models.json:
{
  "providers": {
    "mlx-lm": {
      "baseUrl": "http://localhost:8080/v1",
      "api": "openai-completions",
      "apiKey": "none",
      "models": [
        {
          "id": "imgovind/wrightproduct-v0-lora"
        }
      ]
    }
  }
}

Run Pi

# Start Pi in your project directory:
pi

MLX LM

How to use imgovind/wrightproduct-v0-lora with MLX LM:

Generate or start a chat session

# Install MLX LM
uv tool install mlx-lm
# Interactive chat REPL
mlx_lm.chat --model "imgovind/wrightproduct-v0-lora"

Run an OpenAI-compatible server

# Install MLX LM
uv tool install mlx-lm
# Start the server
mlx_lm.server --model "imgovind/wrightproduct-v0-lora"
# Calling the OpenAI-compatible server with curl
curl -X POST "http://localhost:8000/v1/chat/completions" \
   -H "Content-Type: application/json" \
   --data '{
     "model": "imgovind/wrightproduct-v0-lora",
     "messages": [
       {"role": "user", "content": "Hello"}
     ]
   }'

Docker Model Runner
How to use imgovind/wrightproduct-v0-lora with Docker Model Runner:
```
docker model run hf.co/imgovind/wrightproduct-v0-lora
```

Hermes Agent

How to use imgovind/wrightproduct-v0-lora with Hermes Agent:

Start the MLX server

# Install MLX LM:
uv tool install mlx-lm
# Start a local OpenAI-compatible server:
mlx_lm.server --model "imgovind/wrightproduct-v0-lora"

Configure Hermes

# Install Hermes:
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
hermes setup
# Point Hermes at the local server:
hermes config set model.provider custom
hermes config set model.base_url http://127.0.0.1:8080/v1
hermes config set model.default imgovind/wrightproduct-v0-lora

Run Hermes

hermes

Atomic Chat

OpenClaw

How to use imgovind/wrightproduct-v0-lora with OpenClaw:

Start the MLX server

# Install MLX LM:
uv tool install mlx-lm
# Start a local OpenAI-compatible server:
mlx_lm.server --model "imgovind/wrightproduct-v0-lora"

Configure OpenClaw

# Install OpenClaw:
npm install -g openclaw@latest
# Register the local server and set it as the default model:
openclaw onboard --non-interactive --mode local \
  --auth-choice custom-api-key \
  --custom-base-url http://127.0.0.1:8080/v1 \
  --custom-model-id "imgovind/wrightproduct-v0-lora" \
  --custom-provider-id mlx-lm \
  --custom-compatibility openai \
  --custom-text-input \
  --accept-risk \
  --skip-health

Run OpenClaw

openclaw agent --local --agent main --message "Hello from Hugging Face"

wrightproduct-v0

A model that turns a product idea into the full PM + staff-engineer chain, including the multi-agent work assignments a coding team can execute.

Brief  →  PRD  →  Technical Design  →  ADRs  →  Task Breakdown  →  Agent Orchestration

Fine-tuned from Qwen/Qwen3-30B-A3B-Instruct-2507 (Apache-2.0) on a curated set of real software design documents (Kubernetes KEPs, Python PEPs, Rust RFCs, Kafka KIPs, public ADRs) rewritten into the contract above, plus synthetic scenarios generated by an open-weight teacher.

What it does

Given a brief (idea, users, constraints), it produces:

PRD — problem, goals/non-goals, numbered requirements with MoSCoW priority and testable acceptance criteria, success metrics, scope phasing, risks, and honest open questions.
Technical Design — C4 overview, a requirements-traceability table linking every design element to an R#, data model, APIs, key flows, non-functionals, alternatives considered, rollout and observability.
ADRs — one per significant choice, each with Context / Decision / Alternatives / Consequences.
Task Breakdown — epics and tasks T1..Tn with estimates, dependencies and requirement coverage.
Agent Orchestration — the piece that makes this executable by other coding agents: one ready-to-paste work assignment per task (goal, R#s, interfaces allowed/forbidden, inputs to read), plus coordination protocol and acceptance gates.

Why it exists

General models with a good prompt are strong at prose but leaky on the contract: they write tasks without pairing them to work assignments, invent metrics instead of asking, and size the design for a team the brief never mentioned. This model is fine-tuned to hold the contract and to ask when it does not know.

Usage

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

name = "imgovind/wrightproduct-v0"
tok = AutoTokenizer.from_pretrained(name, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    name, torch_dtype=torch.bfloat16, device_map="auto", trust_remote_code=True
)

messages = [
    {{"role": "system", "content": "You are a staff product manager and staff software architect."}},
    {{"role": "user", "content": brief_yaml}},
]
inputs = tok.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt").to(model.device)
out = model.generate(inputs, max_new_tokens=8000, do_sample=True, temperature=0.2)
print(tok.decode(out[0][inputs.shape[1]:], skip_special_tokens=True))

On a Mac (MLX)

This repo ships an MLX 4-bit copy under mlx/. With mlx-lm:

mlx_lm.generate --model imgovind/wrightproduct-v0/mlx --prompt "..."

Or merge the adapter yourself:

python phase2_finetune/export_mlx.sh checkpoints/sft/full/adapter checkpoints/mlx

Contract

The output is one markdown document with five H1 sections in order: # PRD, # Technical Design, # ADRs, # Task Breakdown, # Agent Orchestration. wrightproduct.contract.validate() checks it mechanically.

Training data provenance

Source	Kind	Licence
Kubernetes KEPs, Python PEPs, Rust RFCs, Kafka KIPs, public ADRs	real design docs, rewritten	Apache-2.0 / MIT / CC0 / public-domain (per item, recorded)
Synthetic scenarios	generated by `Qwen/Qwen3-30B-A3B-Instruct-2507` (Apache-2.0)	generated

No commercial-API outputs are in the training set. Evaluation baselines used a frontier model and are recorded separately under evals/results/, never in data/.

Evaluation

Scored against a frozen 155-scenario brief set with a 13-criterion rubric (PRD quality, design, traceability, calibration, honesty, agent orchestration). Baseline (Qwen3-30B-A3B + strong prompt): 4.45 / 5 with 2,159 TASK_NO_ASSIGNMENT contract violations across 155 documents.

See evals/reports/ for the full numbers.

Limitations

Trained for software / SaaS products. Other domains are out of scope for v0.
The model asks when facts are missing; it does not retrieve current technology facts. Pair it with retrieval if you need up-to-date stack advice.
30B total / 3B active MoE: requires ~18 GB for 4-bit, ~60 GB for bf16.

Licence

Weights are Apache-2.0 (same as the base model). Training code is in the wrightproduct repository.

Downloads last month: -; Downloads are not tracked for this model. How to track

MLX

Hardware compatibility

Quantized

Model tree for imgovind/wrightproduct-v0-lora

Base model

Qwen/Qwen3-30B-A3B-Instruct-2507

Finetuned

(123)

this model