Instructions to use ZENLLC/HUX-1 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use ZENLLC/HUX-1 with Transformers:

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

pipe = pipeline("text-generation", model="ZENLLC/HUX-1")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("ZENLLC/HUX-1")
model = AutoModelForCausalLM.from_pretrained("ZENLLC/HUX-1")
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=40)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps

vLLM

How to use ZENLLC/HUX-1 with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/ZENLLC/HUX-1

SGLang

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

Docker Model Runner
How to use ZENLLC/HUX-1 with Docker Model Runner:
```
docker model run hf.co/ZENLLC/HUX-1
```

Use Cases & Applications: What HUX-1 Can Do (Free to Use)

pinned

by ZENLLC - opened 6 days ago

Discussion

ZENLLC

Owner 6 days ago

HUX-1 Use Cases & Applications

HUX-1 is the internal intelligence layer for Arsenal by ZEN AI Co. Built on top of Qwen3-4B-Instruct-2507, it is a 4B parameter model optimized for AI agent generation, prompt enhancement, structured system outputs, and workflow automation logic. It supports a 256K native context window, excels at tool calling and agentic workflows, and is free to use under Apache 2.0.

Below is a comprehensive list of ways you can use HUX-1 today:

AI Agents & Automation

AI Agent Generation — Automatically generate full agent specs (tools, input/output schemas, success criteria) from plain-English descriptions of a business process
Multi-Stage Agent Flows — Design chained workflows (intake -> classify -> enrich -> draft -> approve) and output them as YAML or JSON for orchestrators like n8n, Zapier, or custom backends
Background Automations — Replace per-token paid LLM calls in n8n/Zapier/Make workflows for routing, classification, summarization, data cleaning, enrichment, and lead qualification
Self-Refinement Loops — Use HUX-1 to critique and improve existing agent configs, prompt templates, guardrails, and tool descriptions
Tool Calling & Planning — Leverage native function-calling support (via Qwen-Agent or custom) to plan tool sequences, parse outputs, and route to downstream services

Structured Data & Reasoning

Text-to-Structure — Extract entities, fields, and relationships from unstructured text into JSON, CSV, or database-ready formats
Conditional Logic Generation — Generate IF/ELSE trees, decision tables, and rule engines from natural language business policies
Batch Processing — Overnight CSV/JSON row processing: classify records, generate follow-up messages, extract entities, flag anomalies
Data Cleaning & Normalization — Standardize messy data, fill missing fields, deduplicate, and reformat at scale
Schema Inference — Analyze sample data and auto-generate schemas, validation rules, or type definitions

Coding & Technical Tasks

Code Generation — Generate boilerplate, scripts, API clients, and small utilities in JavaScript, Python, HTML/CSS, and p5.js
Code Review & Critique — Review existing code for bugs, security issues, and improvements; suggest refactors
Prompt Engineering — Auto-rewrite rough instructions into production-ready system prompts with edge-case handling
Test Suite Generation — Given a system prompt or function, generate adversarial and normal test inputs with expected behaviors
Technical Documentation — Generate READMEs, API docs, changelogs, and inline code comments

Content & Communication

Message Drafting — Write offers, rejection emails, outreach messages, follow-ups, and professional correspondence
Template Libraries — Generate reusable templates for job descriptions, proposals, reports, and internal documentation
Summarization — Condense long documents, meeting notes, research papers, or web content into concise summaries
Translation & Multilingual Support — Process long-tail multilingual knowledge; translate and adapt content across languages
Tone & Style Adaptation — Rewrite content for different audiences (executive, 9th-grade, technical, casual)

Education & AI Literacy (ZEN / BGCGW)

Student Playgrounds — Let students build and deploy small HF Spaces that call HUX-1 to power their own AI projects
AI Tutor — Explain LLMs, Web3, and automation concepts in age-appropriate language; generate step-by-step learning paths
Project Scaffolding — Turn BGCGW programs into quests/projects with instructions, rubrics, and starter code
Lesson Plan Generation — Auto-generate lesson plans, quizzes, and hands-on exercises for AI and automation curricula
Rubric Alignment — Score student projects against rubrics and explain scoring decisions with supporting rationale

STEM, Math & Science

Math Problem Solving — Solve AIME-level math problems with step-by-step working (AIME25: 47.4 benchmark)
Science Q&A — Explain scientific concepts, walk through experiments, and generate study guides
Technical Comprehension — Read and explain research papers, datasheets, and technical documentation
Worksheet Generation — Create math problems, word problems, and practice exercises at specified difficulty levels

Long-Context Applications (256K tokens)

Document Analysis — Ingest entire policy documents, contracts, handbooks, or technical specs and Q&A against them
Conversation Memory — Maintain context across very long chat histories without dropping early context
Codebase Understanding — Load large code repositories and reason about architecture, dependencies, and changes
Book / Long-Form Processing — Summarize, analyze, or extract information from books and lengthy reports

Business & Ops

Recruiting & HR — Classify resumes by role/seniority, flag risks, generate offer/rejection/templated outreach messages
Ticket Triaging — Classify support tickets, route to correct teams, and draft initial responses
Grant Writing — Help nonprofits draft and refine grant proposals, budgets, and impact narratives
Process Mapping — Convert verbal/written process descriptions into flowcharts, decision trees, and SOPs
Internal Copilots — Power Notion, Slack, Discord, and Airtable bots for team knowledge, reminders, and quick lookup

Commercial Products (Apache 2.0 Licensed)

White-Label Automators — Lightweight SaaS for small orgs needing intake -> triage -> follow-up flows
Niche Copilots — Domain-specific assistants (e.g., Coach-HUX for young founders, GrantWriter-HUX for nonprofits)
SMB AI Tools — Customer support bots, email classifiers, content generators, document processors
Edge / Offline Tools — Eventually deploy on smaller GPU/CPU boxes or edge devices since the model is only 4B

Technical Specs

Base: Qwen3-4B-Instruct-2507
Params: 4.0B (3.6B non-embedding)
Layers: 36
Heads: 32 Q / 8 KV (GQA)
Context: 256K native (reduce to ~32K if OOM)
Tensor Type: BF16
License: Apache 2.0
Deployment: transformers, vLLM, SGLang, TGI, HF Inference API

Benchmarks

MMLU-Pro: 69.6
AIME25: 47.4
LiveCodeBench: 35.1
Arena-Hard: 43.4
BFCL-v3: 61.9

How to Use

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "ZENLLC/HUX-1"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto")

messages = [{"role": "user", "content": "Your prompt here"}]
inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)
output = model.generate(inputs, max_new_tokens=1024)
response = tokenizer.decode(output[0], skip_special_tokens=True)

Feel free to use HUX-1 however you like. It's built for you — whether you're automating your own workflows, building products, or learning AI. If you come up with cool use cases, drop them in this thread!

- ZEN AI Co

ZENLLC pinned discussion 6 days ago

Upload images, audio, and videos by dragging in the text input, pasting, or clicking here.

Tap or paste here to upload images

· Sign up or log in to comment