occamy-1.0

Evolving Data, Expanding Agent Capability

Introduction

We present Occamy-35B, an efficient agentic model designed for long-horizon decision-making, coordinated multi-tool use, and complex business workflows. Post-trained from Qwen3.6-35B-A3B, Occamy demonstrates strong stability and task-completion capability on challenging Claw-style tasks.

As LLMs evolve from passive responders into agents capable of executing long-horizon tasks in interactive environments, static training data can no longer keep pace with their rapidly changing capability boundaries.

The key innovation behind Occamy is Data RSI (Data Recursive Self-Improvement), a model-driven data evolution framework. For each rollout, the system dynamically composes a new executable task from: Persona × Tools × Fixtures × Skill x Constraints × Grader. Rollout outcomes are fed back into the data generator: failures reveal capability gaps, while successes expose reusable behavioral patterns. These signals guide subsequent task generation toward the model's evolving capability frontier, forming a closed loop of policy-adaptive data evolution.

Across agentic coding, Claw-style workflows, and real-world e-commerce scenarios, Occamy-35B demonstrates strong and robust capabilities, matching or even surpassing substantially larger models such as GLM-5.2 and DeepSeek-V4 Pro.

Open Source

We open-source Occamy-35B, together with a subset of our data derived from real-world e-commerce scenarios, to support and advance open research on agentic models. We have also open-sourced the Occamy AI Blog, where we share our latest research, technical insights, and project updates.

Model Performance

We evaluate Occamy-35B across agentic coding, Claw-style workflows, multi-turn tool use, and real-world e-commerce scenarios. It matches or outperforms several substantially larger open-weight and proprietary models, highlighting its strong generalization across both business workflows and agentic environments.

* Indicates that the model was evaluated by our team. Terminal-Bench 2.1: Harbor/Terminus-2 harness; 3-hour timeout; 32 CPU/48 GB RAM; temperature=1.0, top_p=0.95, top_k=20, max_tokens=80K, and 256K context; average of two runs. SWE-bench Pro: Internal agent scaffold with bash and str_replace_edit tools; temperature=1.0, top_p=0.95, and 200K context. We use the unmodified public set. All models were re-evaluated in-house under this identical setup; no officially reported numbers are adopted in this table. τ³-Bench: We report Banking Knowledge results following the official example configuration, using AllTools retrieval and GPT-5.2 with reasoning_effort=low as the user simulator.

Usage

For production deployment, we recommend serving Occamy-35B with SGLang or vLLM through an OpenAI-compatible API.

SGLang Deployment

SGLang >=0.5.10 is recommended.

Install SGLang:

uv pip install "sglang[all]>=0.5.10"

Launch the server with the Qwen3 reasoning parser and Qwen3-Coder tool-call parser:

python -m sglang.launch_server \
  --model-path <ORG>/<MODEL_NAME> \
  --host 0.0.0.0 \
  --port 8000 \
  --tp-size 8 \
  --mem-fraction-static 0.8 \
  --context-length 262144 \
  --reasoning-parser qwen3 \
  --tool-call-parser qwen3_coder

Once the server is running, the OpenAI-compatible API is available at:

http://localhost:8000/v1

vLLM Deployment

vLLM >=0.19.0 is recommended.

Install vLLM:

uv pip install "vllm>=0.19.0" --torch-backend=auto

Launch the server with automatic tool selection enabled:

vllm serve <ORG>/<MODEL_NAME> \
  --host 0.0.0.0 \
  --port 8000 \
  --tensor-parallel-size 8 \
  --max-model-len 262144 \
  --reasoning-parser qwen3 \
  --enable-auto-tool-choice \
  --tool-call-parser qwen3_coder

Once the server is running, the OpenAI-compatible API is available at:

http://localhost:8000/v1

OpenAI-Compatible API

SGLang and vLLM expose the same OpenAI-compatible API, allowing them to share the same client implementation.

Install the OpenAI Python SDK:

pip install -U openai

Text Generation

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="EMPTY",
)

response = client.chat.completions.create(
    model="<ORG>/<MODEL_NAME>",
    messages=[
        {
            "role": "user",
            "content": "Analyze the current task and provide a complete solution.",
        }
    ],
    temperature=1.0,
    top_p=0.95,
    max_tokens=32768,
    extra_body={
        "top_k": 20,
    },
)

message = response.choices[0].message

print("Thinking:", getattr(message, "reasoning_content", None))
print("Answer:", message.content)

[!NOTE] Occamy-35B is primarily designed to operate in Thinking mode. Disabling reasoning through options such as enable_thinking=False or the /nothink command is not recommended.

Function Calling

When the tool-call parser is enabled during deployment, tool definitions can be passed directly through the OpenAI-compatible API:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="EMPTY",
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_order",
            "description": "Retrieve order information using an order ID.",
            "parameters": {
                "type": "object",
                "properties": {
                    "order_id": {
                        "type": "string",
                        "description": "The identifier of the order to retrieve.",
                    }
                },
                "required": ["order_id"],
            },
        },
    }
]

response = client.chat.completions.create(
    model="<ORG>/<MODEL_NAME>",
    messages=[
        {
            "role": "user",
            "content": "Check the current processing status of order A-1024.",
        }
    ],
    tools=tools,
    tool_choice="auto",
    temperature=1.0,
    top_p=0.95,
    max_tokens=32768,
    extra_body={
        "top_k": 20,
    },
)

message = response.choices[0].message

if message.tool_calls:
    for tool_call in message.tool_calls:
        print("Tool name:", tool_call.function.name)
        print("Tool arguments:", tool_call.function.arguments)
else:
    print(message.content)

Direct Inference with Transformers

For local testing, Occamy-35B can also be loaded directly with Hugging Face Transformers.

Install the required dependencies:

pip install -U transformers accelerate pillow torchvision

Run inference:

from transformers import AutoModelForMultimodalLM, AutoProcessor

model_id = "<ORG>/<MODEL_NAME>"

processor = AutoProcessor.from_pretrained(
    model_id,
    trust_remote_code=True,
)

model = AutoModelForMultimodalLM.from_pretrained(
    model_id,
    torch_dtype="auto",
    device_map="auto",
    trust_remote_code=True,
)

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": "Analyze this problem and provide a complete solution.",
            }
        ],
    }
]

inputs = processor.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=8192,
)

generated_ids = outputs[0][inputs["input_ids"].shape[-1] :]

response = processor.decode(
    generated_ids,
    skip_special_tokens=True,
)

print(response)

For production deployment, long-context inference, or high-concurrency workloads, we recommend using SGLang or vLLM instead of direct Transformers inference.