Instructions to use charge-ai/charge-30b with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use charge-ai/charge-30b with Transformers:

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

pipe = pipeline("text-generation", model="charge-ai/charge-30b")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("charge-ai/charge-30b")
model = AutoModelForCausalLM.from_pretrained("charge-ai/charge-30b", device_map="auto")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use charge-ai/charge-30b with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/charge-ai/charge-30b

SGLang

How to use charge-ai/charge-30b 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 "charge-ai/charge-30b" \
    --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": "charge-ai/charge-30b",
		"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 "charge-ai/charge-30b" \
        --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": "charge-ai/charge-30b",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use charge-ai/charge-30b with Docker Model Runner:
```
docker model run hf.co/charge-ai/charge-30b
```

Charge 30B

Site: https://chargeai.bid · X: @chargeairh · Token: $CHARGE 0x7b8892cea949bc60d494681d1bc3ea96071ab0b8 on the Surplus LLM launchpad

Charge reads Pons launches on Robinhood Chain. Give it a launch's public facts and it tells you how live the launch is, its charge, and how launches like it did over the next 24 hours.

It is Qwen3-30B-A3B-Instruct-2507 fine-tuned on the Pons tape: 13,250 ETH-paired launches from 2026-10-05 to 2026-10-12, read at fixed ages and every 10 minutes while they traded, each labelled with what happened in the next 24 hours.


Base model	Qwen3-30B-A3B-Instruct-2507 (Apache 2.0)
Parameters	30.5B total, 3.3B active per token (mixture of experts)
Method	LoRA (r 32, alpha 64) on attention and experts, merged into the base weights
Training rows	33,661 (2,149 general-chat rows)
License	Apache 2.0

What it says

$PONS100 · Pons Index · 0x47cc…f10a
age 15m · mc $41k · ATH $53k (-22%) · launched at $13k · graduated 5m ago
last 5m: 274 trades · 160 buyers / 71 sellers · buys $4.6k / sells $5.4k · -14%
last 15m: 663 trades · 338 buyers / 135 sellers · buys $31k / sells $23k · +219%
since launch: 347 buyers · 135 sellers · median buy $25 · top 3 buyers = 8% of buys
holders ~268 · top 10 hold 22% · biggest 3.6%
dev: holds 3.0% · bought $135 · sold $0
first-30s buyers: 52, bought 92.1% · sold 85% of it
creator: 0 other launches in the 24h before · 0 graduated before
ticker: 2 other $PONS100 launched in the 24h before
socials: X @ponslndex (1st launch on it) · site pons100.com (1st launch on it)

⚡⚡ Charge 95% · overcharged
Launches I read like this, next 24h: 17% doubled before halving · 52% halved first · 18% reached $50k.

What stands out:
+ graduated 5m ago
± buyers out-spent sellers by $11k in the last hour (moves both ways)
± bounced 3.5x off its low (moves both ways)
+ ~268 holders

Top of the board. Most launches this hot give back half before they double.

The bands

Charge ranks a launch against every live launch it saw: 90% means busier and stronger than 90% of them. On days it never saw in training (2026-10-10 onward), launches in each band did this over the next 24 hours (each launch counted once):

Charge	Launches	Doubled before halving	Halved first
⚪ flat	548	0.2%	0.0%
🪫 low	1,729	0.2%	0.2%
🔋 mid	1,120	2.6%	7.7%
⚡ charged	241	9.0%	57%
⚡⚡ overcharged	26	15%	64%

A higher charge means more action in both directions, not more safety. The hottest launches halve first more often than they double. The ones that run come from the top bands, and so do the round-trips.

How it was tested

The test model is the same recipe trained only on launches before 2026-10-10, then scored on launches from 2026-10-10 to 2026-10-12 that it never saw. This released model is trained on every launch through 2026-10-12. Ranking live launches by their chance of doubling before halving (AUC, each launch weighted once):

	AUC
Charge 30B (test model)	0.93
Its teacher (gradient-boosted model it learned from)	0.92
Rule: most net buying in the last hour	0.77
Rule: most buyers in the last 15 minutes	0.73

Against frontier models

The same question, the same facts cards: 600 snapshots of 546 live launches from 2026-10-10 to 2026-10-12 (every launch that doubled first is included). The Claude models also got a primer on how Pons works and the 6% base rate, and rated 20 snapshots at a time.

	AUC	Harder subset (Charge read mid or hotter)
Charge 30B	0.91	0.79
Claude Opus 5.5	0.87	0.73
Claude Sonnet 5.5	0.83	0.66
Most net buying, last hour	0.77	0.65
Most buyers, last 15 min	0.73	0.64

Check it yourself: every facts card, every model's answer, the outcomes and a scoring script are public at charge-ai/charge-vs-claude (python score.py).

Against Claude Opus 5.5: ahead in 100.0% of 2,000 resamples of the launches (gap +0.038, 95% interval +0.018 to +0.057). Against Claude Sonnet 5.5: ahead in 100.0% of 2,000 resamples of the launches (gap +0.082, 95% interval +0.055 to +0.108).

Speed and cost. One read takes 0.74 s on a single 48 GB L40S in FP8 (Surplus serves 20-32B models on their own 48 GB GPU in FP8; measured on the test model, same architecture), against 2.7 s for Claude Opus 5.5 and 2.4 s for Sonnet 5.5 through the API. At Surplus's $0.10 per million tokens a read (~700 tokens) costs about $0.07 per 1,000 reads; Opus 5.5 costs $3 or more per 1,000 reads even batched 20 at a time.

The model wrote a well-formed read for 100% of 8,103 held-out snapshots, landed in the same band as its teacher 86% of the time (99.8% within one band) and named 86% correct "what stands out" lines. It is good at telling a launch that is going flat from a live one. It is not a runner oracle.

What it can't do

It doesn't see the chain. It reads the facts you give it: age, market cap and ATH, trades, buyers and sellers per window, holders, the dev's own trades, first-30-second buyers, the creator's other launches, socials.
It doesn't read contracts. Honeypots and hook traps need a sell simulation.
Eight days of one launchpad (October 5–12). Markets change; the numbers above are what happened on those days.
Not financial advice.

How it was built

Data: public trades of ETH-paired Pons launches. Only facts anyone can see: price, flows, buyers, holders worked out from trades, the dev's own trades, ticker copies, socials.
Teacher: a shallow gradient-boosted model on those facts, each launch weighted equally (a launch that trades for hours appears as many snapshots), stacked with net buying in the last hour.
"What stands out": fixed checks, shown with + or − only when launches with that trait did better or worse than launches of the same charge on the training days.
Text: every answer is rendered from data by templates. The general-chat rows are human-written prompts from OpenAssistant oasst1 (Apache 2.0) answered by the base model itself, so the fine-tune keeps its manners.

Run it

from transformers import AutoModelForCausalLM, AutoTokenizer

tok = AutoTokenizer.from_pretrained("charge-ai/charge-30b")
model = AutoModelForCausalLM.from_pretrained("charge-ai/charge-30b", dtype="auto", device_map="auto")
messages = [{"role": "user", "content": "Read this launch:\n$TICKER · Name · 0x1234…abcd\nage 25m · mc $14k · ..."}]
ids = tok.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt").to(model.device)
print(tok.decode(model.generate(ids, max_new_tokens=300, do_sample=False)[0][ids.shape[1]:], skip_special_tokens=True))

The chat template already carries Charge's system prompt; you don't need to pass one.

License

Apache 2.0, the same as the base model.

surplus-launcher: 0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca

Downloads last month: 201

Safetensors

Model size

31B params

Tensor type

BF16

Model tree for charge-ai/charge-30b

Base model

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

Finetuned

(110)

this model