Apex-35B-V1.0 is the first model from Apex Intelligence, developed for both general-purpose use and research and supported by the Claude Code (v2.1.280 preferred) harness. It combines coding, tool use, question answering, and deep search with research tasks in AI, computational science, and robotics simulation.
Built on Qwen3.6-35B-A3B, the model is further trained on proprietary datasets and research trajectories. Its development incorporates recursive self-improvement (RSI) through Apex Research, an automated research system that contributes to training-data construction, automated experiments, training-recipe exploration, GPU kernel optimization, and inference optimization. Validated results from this process feed into subsequent development.
GGUF builds for llama.cpp, Unsloth, and other local runtimes are available in Apex-35B-V1.0-GGUF: BF16 and 28 quantizations, from Q8_0 (37.8 GB) to IQ1_S (9.0 GB).
General and research capabilities. Covers everyday coding, question answering, search, and agentic tasks, alongside scientific and engineering research workflows.
Research through computation and feedback. Plans computations, writes and runs programs, and uses results or execution feedback to revise its approach, including in fluid dynamics and robotics simulation.
Self-improving development. Apex Research generated training data for the model's weak areas, refined the training recipe based on experimental feedback, and optimized the training and inference infrastructure.
Dynamic thinking. Determines whether to reason and how long to reason on each turn, without manual mode switching.
Sparse architecture and long context. Uses 35B total parameters with approximately 3B activated per token, and a context window of 262,144 tokens shared by input and output, supporting large code repositories and long multi-turn tool interactions.
Apex-35B-V1.0 can be served with popular inference frameworks through an OpenAI-compatible API. The commands below start an endpoint at http://localhost:8000/v1 and, except for transformers serve and llama.cpp (see their sections), set the served model name to Apex-35B-V1.0, which the examples use as model. To use local weights, replace Apexintelligence-AI/Apex-35B-V1.0 with the local directory; the served model name stays the same.
Important. The checkpoint includes its own chat template (chat_template.jinja). Every framework below loads it automatically (llama.cpp with --jinja). Do not pass --chat-template, and do not replace it with the Qwen3.6 template: Apex-35B-V1.0 expects the generation prompt to end with <think>.
Important. The model has a context length of 262,144 tokens, shared by input and output. The BF16 weights take about 72 GB. One GPU with 141 GB or more (for example H20-3e, H200, or B200) runs the model with tensor parallel size 1 and the full context. On H100 NVL (94 GB) we ran SGLang and vLLM with tensor parallel size 2, and TokenSpeed with tensor parallel size 1; on A100 (40 GB) we ran SGLang and vLLM with tensor parallel size 4. On other GPUs with less memory, increase the tensor parallel size. A shorter context saves little memory: the KV cache for the full 262,144 tokens takes about 5.4 GB.
Note. The install commands below install CUDA 13 builds (PyTorch for SGLang and Transformers, and the vLLM wheel). We ran them with NVIDIA drivers 580 and 595. On a machine with 4 × A100 40 GB and driver 570 (CUDA 12.8) we observed:
vLLM started after reinstalling its CUDA 12.9 build: uv pip install "vllm==0.32.0+cu129" --extra-index-url https://wheels.vllm.ai/0.32.0/cu129 --reinstall-package vllm.
SGLang and Transformers stopped with "The NVIDIA driver on your system is too old" and ran only after loading NVIDIA's CUDA 13 forward-compatibility package (cuda-compat-13-0).
SGLang with MTP started, but its first request failed while FlashInfer compiled its kernels; we did not find a fix. We did not test driver 570 on Hopper or Blackwell GPUs.
Tip. Install each framework in its own virtual environment. We tested with Python 3.12 (all frameworks) and 3.13 (vLLM and TokenSpeed), for example:
vLLM returns the thinking in the reasoning field instead of reasoning_content. The first start can download and compile kernels, which needs internet access and several minutes.
This is the nightly build we tested (2026-10-25); later builds may behave differently. The pin covers only the tokenspeed package; its dependencies come from the nightly index on the day you install. With uv pip install, add --index-strategy unsafe-best-match so that uv takes packages from both indexes. In TokenSpeed the tool-call parser is named qwen_coder, not qwen3_coder. Without the two parser flags, the thinking and the tool calls stay in content. The first start compiles kernels, which can take 15 to 25 minutes; later starts reuse the cache. During startup each GPU process used about 280 GiB (300 GB) of host memory in our tests, so tensor parallel size 2 needs about 560 GiB (600 GB) or more. On H100 NVL, tensor parallel size 2 stopped at startup with "an illegal memory access was encountered" in our test; tensor parallel size 1 on one H100 NVL worked.
KTransformers runs the experts on the CPU and the rest of the model on the GPU. Install it as described in its deployment guide, download the weights to a local directory, and add the reasoning and tool-call parsers to the launch command:
This command is based on the KTransformers guide, with the parsers, served model name and port added. --max-total-tokens 32000 limits the KV cache to about 32,000 tokens, so a request cannot use the 65,536-token output budget from the examples. For longer prompts and outputs, raise --max-total-tokens or lower max_tokens in the request.
With kt-kernel / sglang-kt 0.7.2 we also needed these packages:
pip install nvidia-cudnn-cu12==9.16.0.29
# Hopper and Ampere GPUs (tested: H20, H200, H100 NVL, A100):
pip install --no-deps sgl-kernel==0.3.21
# Blackwell GPUs (tested: B200); also add --moe-runner-backend triton to the launch command:
pip install ktransformers==0.7.2
pillow and torchvision are needed to load the processor files shipped with the checkpoint. transformers serve has no served-model-name option: set model in the examples to the path or repository ID that you passed to it. It rejects the top_k request field, so remove it from extra_body. It does not pass the thinking of earlier turns back to the model; for multi-turn and agent use, prefer SGLang, vLLM, or TokenSpeed. If GET /v1/models returns HTTP 500 (CacheNotFound), create the hub folder under $HF_HOME; chat requests are not affected.
GGUF builds for llama.cpp, Unsloth, and other local runtimes are in Apex-35B-V1.0-GGUF; the Download Model table lists all files. For example, with a recent llama.cpp build (llama-server on PATH):
--jinja is required: it applies the chat template embedded in the file. -c sets the context for the prompt and the output together; with -c 32768, a long thinking can be cut off before the 65,536-token budget of the examples, so raise -c if you have the memory. For Unsloth and the other files, see the GGUF model card.
The chat completions API is accessible through standard HTTP requests or the OpenAI SDK. Install the SDK in a separate environment from the server (SGLang 0.5.22 and sglang-kt 0.7.2 require openai==2.6.1; upgrading openai there breaks that requirement) and configure the endpoint:
pip install -U openai
# Set the following accordingly
export OPENAI_BASE_URL="http://localhost:8000/v1"
export OPENAI_API_KEY="EMPTY"
Tip. We recommend temperature=1.0, top_p=0.95, top_k=20, and max_tokens=65536 (the output budget includes the thinking). The first three values are also the defaults in generation_config.json.
Important. Apex-35B-V1.0 decides on each turn whether to think and for how long. The thinking is returned in reasoning_content (reasoning in vLLM) and the answer in content. For multi-turn conversations and tool calls, append the complete assistant message to messages, for example with msg.model_dump(exclude_none=True), and pass extra_body={"chat_template_kwargs": {"preserve_thinking": True}} to keep the thinking of earlier turns. With SGLang, model_dump() can print a Pydantic serializer warning about the metadata field; it does not change the result.
from openai import OpenAI
client = OpenAI() # reads OPENAI_BASE_URL and OPENAI_API_KEY
questions = [
"Water flows through a pipe with an inner diameter of 5 cm at a mean velocity of 2 m/s. Take the kinematic viscosity as 1.0×10⁻⁶ m²/s. "
"What is the Reynolds number, and is the flow laminar or turbulent? Please answer briefly.",
"What if the velocity drops to 2 cm/s?",
]
messages = []
for q in questions:
messages.append({"role": "user", "content": q})
resp = client.chat.completions.create(
model="Apex-35B-V1.0",
messages=messages,
temperature=1.0,
top_p=0.95,
max_tokens=65536,
extra_body={
"top_k": 20,
"chat_template_kwargs": {"preserve_thinking": True},
},
)
choice = resp.choices[0]
msg = choice.message
text = (msg.content or "").strip()
print("Q:", q)
if choice.finish_reason == "length" or not text:
print("A: (no complete answer: the output was cut off or empty)")
break
print("A:", text, "\n")
messages.append(msg.model_dump(exclude_none=True))
The model calls tools in the Qwen XML format; the tool-call parser of each framework converts the calls into standard tool_calls. Return each tool result with role="tool" and its tool_call_id:
import json
from openai import OpenAI
client = OpenAI()
# kinematic viscosity at 20 °C (m²/s), approximate example values; glycerol means pure glycerol
VISCOSITY = {"water": 1.0e-6, "glycerol": 1.12e-3, "air": 1.5e-5}
def get_fluid_properties(fluid):
if fluid not in VISCOSITY:
return {"error": f"unknown fluid: {fluid}", "available": list(VISCOSITY)}
return {"fluid": fluid, "temperature_C": 20, "kinematic_viscosity_m2_s": VISCOSITY[fluid]}
tools = [{
"type": "function",
"function": {
"name": "get_fluid_properties",
"description": "Look up the kinematic viscosity of a fluid at 20 °C",
"parameters": {
"type": "object",
"properties": {"fluid": {"type": "string", "enum": list(VISCOSITY)}},
"required": ["fluid"],
},
},
}]
messages = [{"role": "user", "content": (
"A pipe has an inner diameter of 5 cm and a mean flow velocity of 0.5 m/s. Is the flow laminar or turbulent "
"when it carries water at 20 °C, and when it carries glycerol at 20 °C? Use get_fluid_properties to look up "
"the kinematic viscosity, then compute the Reynolds numbers and explain briefly. Answer in plain text, without LaTeX."
)}]
for _ in range(8): # at most 8 model requests
resp = client.chat.completions.create(
model="Apex-35B-V1.0",
messages=messages,
tools=tools,
tool_choice="auto",
temperature=1.0,
top_p=0.95,
max_tokens=65536,
extra_body={"top_k": 20, "chat_template_kwargs": {"preserve_thinking": True}},
)
choice = resp.choices[0]
msg = choice.message
messages.append(msg.model_dump(exclude_none=True))
if choice.finish_reason == "length": # cut off: do not run partial tool calls
print("(no complete answer: the output was cut off)")
break
if not msg.tool_calls: # no tool call: require a nonempty final answer
text = (msg.content or "").strip()
if not text:
print("(no complete answer: the output was empty)")
else:
print(text)
break
for call in msg.tool_calls:
args = call.function.arguments
if call.function.name != "get_fluid_properties":
result = {"error": "unknown tool: " + call.function.name}
else:
try:
args = json.loads(args or "{}")
result = get_fluid_properties(**args)
except (json.JSONDecodeError, TypeError) as exc:
result = {"error": "invalid tool arguments: " + str(exc)}
print("[tool]", call.function.name, args, "->", result)
messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
else:
print("(reached the limit of 8 requests without a final answer)")
import os
os.environ["HF_ENDPOINT"] = "https://freeweights.allternit.com"
from transformers import AutoModelForCausalLM, AutoTokenizer
tok = AutoTokenizer.from_pretrained("Apexintelligence-AI/Apex-35B-V1.0", revision="5105f8f9ed8fd8212a72da546bcbb4f01d2cfd68")
model = AutoModelForCausalLM.from_pretrained("Apexintelligence-AI/Apex-35B-V1.0", revision="5105f8f9ed8fd8212a72da546bcbb4f01d2cfd68", device_map="auto")
