⚡ Uraion Forge 2B (Apple Silicon MLX Release)

Sovereign Edge Reasoning & Agentic Tool Engine Native to Apple Silicon (M1/M2/M3/M4/M5/M6)

Engineered by Uraion Labs

Overview

Uraion Forge 2B MLX is the official, bare-metal Apple Silicon release of Uraion Forge 2B, specifically packaged and optimized for Apple's MLX framework. Engineered by Uraion Labs, Forge 2B brings production-grade autonomous agent reasoning, deterministic multi-turn tool calling, and high-throughput quantitative computing directly to MacBooks and Mac desktops powered by M1, M2, M3, M4, M5, and M6 processors.

By exploiting Apple Silicon's Unified Memory Architecture (UMA), Forge 2B eliminates PCIe bus transfer latency entirely, keeping model weights, KV caches, and activation tensors resident in shared high-bandwidth memory. The result is instantaneous cold-starts, sustained generation speeds exceeding 90–120+ tokens per second, and unprecedented energy efficiency for local agent execution.

Why MLX for Uraion Forge 2B?

Apple Silicon's unified memory and Metal Performance Shaders provide a unique execution environment for compact edge agents:

• ⚡ Blazingly Fast Local Edge Execution: Generates 90–120+ tokens/second on standard Apple Silicon MacBooks (M1 Pro/Max, M2, M3 Pro/Max, M4, M5, M6). Real-time interactive response rates with near-zero latency.
• 🧠 Unified Memory Architecture (UMA): CPU and GPU access identical physical memory pools at up to 800+ GB/s bandwidth. Zero memory copy overhead, zero PCIe serialization bottlenecks.
• 🔋 Extreme Energy & Battery Efficiency: Run continuous multi-turn agentic workflows unplugged on MacBook Air or MacBook Pro hardware with negligible battery draw and near-silent operation.
• 📦 Ultra-Compact Quantized Memory Footprints:
  • 4-Bit Quantized (q4): ~1.2 GB RAM — Runs effortlessly on base 8 GB or 16 GB Macs alongside heavy developer workloads.
  • 8-Bit Quantized (q8): ~2.3 GB RAM — Near bit-exact retention of 16-bit float reasoning accuracy with a 50% memory reduction.
  • 16-Bit Native (bfloat16): ~4.6 GB RAM — Full precision for reference quantitative calculations and analytical tasks.
• 🛠️ Deterministic Agentic Tool Reliability (90.5%): Trained to execute complex API transactions, handle concurrency conflicts (409 Conflict), manage retry backoffs, and query for clarifications with an interrogative question ending in '?' when missing parameters are detected.

Empirical Benchmark Performance

Uraion Forge 2B has been evaluated across held-out confirmation benchmarks, long-context retrieval suites, and general capability retention probes.

1. Sealed Confirmation Suite (41 Sealed Held-Out Tasks)

Evaluated across 21 multi-turn agentic tool workflows and 20 programmatic coding tasks in 6 distinct software environments:

[!TIP] Mode Selection Guideline:

• Primary Mode (thinking: true): Emits <think>...</think> reasoning tokens. Delivers 90.5% tool success on complex multi-turn API workflows, state drift recovery, and concurrency management.
• Secondary Mode (thinking: false): Bypasses internal thinking tokens for instant direct programmatic answers. Achieves 0 truncations and tenfold faster execution for standard code generation and direct queries.

2. General Capability Retention & Long-Context Suite

Forge 2B was audited across the 252-probe General Retention Suite to guarantee that specialized tool tuning preserved base foundation competencies:

3. MLX vs. PyTorch Performance on Apple Silicon (M3 Max Benchmark)

Comprehensive comparison measuring generation throughput, memory consumption, cold-start initialization, and thermal efficiency on Apple Silicon hardware:

Technical Specifications

Quickstart Guides

1. Installation

Install the official MLX Language Model package via pip:

pip install --upgrade mlx-lm

2. One-Line CLI Inference

Run immediate zero-code command-line generation directly on your Mac:

mlx_lm.generate \
  --model uraionlabs/uraion-forge-2b-mlx \
  --prompt "Write an optimized Python function to calculate the running exponential moving average (EMA) of a financial timeseries." \
  --max-tokens 512 \
  --temp 0.2

3. Python API with Streaming Generation

Use Apple Silicon's native Python API for high-throughput streaming:

from mlx_lm import load, stream_generate

# Load Forge 2B onto Apple Silicon GPU (Unified Memory)
model_repo = "uraionlabs/uraion-forge-2b-mlx"
model, tokenizer = load(model_repo)

# Format structured chat prompt
messages = [
    {
        "role": "system",
        "content": "You are Uraion Forge, an advanced autonomous reasoning and coding assistant developed by Uraion Labs."
    },
    {
        "role": "user",
        "content": "Write an asynchronous ring buffer class in Python with thread-safe append and pop methods."
    }
]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)

print("\n--- Streaming Response from Apple Silicon ---")
for response in stream_generate(model, tokenizer, prompt=prompt, max_tokens=1024, temp=0.2):
    print(response.text, end="", flush=True)
print()

4. Local OpenAI-Compatible Server with Streaming and Tools

Launch an OpenAI-compatible HTTP server running locally on your Mac. You can use standard tools, Cursor, Continue.dev, LangChain, or the official OpenAI client library:

Launch with sample_mlx_server.py:

python sample_mlx_server.py --model uraionlabs/uraion-forge-2b-mlx --port 8080

Or launch with the built-in MLX CLI:

mlx_lm.server --model uraionlabs/uraion-forge-2b-mlx --port 8080

Querying the local server via curl:

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uraionlabs/uraion-forge-2b-mlx",
    "messages": [
      {"role": "system", "content": "You are Uraion Forge, an autonomous agent."},
      {"role": "user", "content": "Calculate the rolling volatility of an asset return stream."}
    ],
    "temperature": 0.2,
    "max_tokens": 512
  }'

Querying via official OpenAI Python SDK:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8080/v1", api_key="not-needed")

response = client.chat.completions.create(
    model="uraionlabs/uraion-forge-2b-mlx",
    messages=[
        {"role": "system", "content": "You are Uraion Forge, an advanced agent."},
        {"role": "user", "content": "Write a vectorized sliding window function using NumPy."}
    ],
    temperature=0.2,
    stream=True
)

for chunk in response:
    content = chunk.choices[0].delta.content
    if content:
        print(content, end="", flush=True)
print()

Tool Calling & Disambiguation Format

Uraion Forge 2B features native deterministic function invocation. When presented with JSON tool schemas in the system prompt:

1. Fully-Specified Queries $\to$ Structured JSON Tool Call: The model emits a clean, markdown-fenced JSON payload matching the requested function.

2. Omitted / Ambiguous Parameters $\to$ Explicit Clarification Query: Rather than hallucinating default or false arguments, Forge 2B stops and asks the user for clarification with an interrogative question ending with '?'.

Example Python Demonstration:

import json
from mlx_lm import load, generate

model, tokenizer = load("uraionlabs/uraion-forge-2b-mlx")

# Define tools
tools = [
    {
        "type": "function",
        "function": {
            "name": "query_timeseries_metric",
            "description": "Query historical metric time series data for an asset or cluster.",
            "parameters": {
                "type": "object",
                "properties": {
                    "asset_id": {"type": "string", "description": "Asset or cluster symbol."},
                    "metric_name": {"type": "string", "description": "Metric name (e.g. 'volume_vwap', 'latency_p99')."},
                    "window_minutes": {"type": "integer", "description": "Window duration (1 to 1440 minutes)."}
                },
                "required": ["asset_id", "metric_name"]
            }
        }
    }
]

system_prompt = (
    "You are Uraion Forge, an autonomous agent capable of utilizing external tools and APIs.\n"
    "When invoking a tool, respond with a JSON markdown code block matching the specified schema.\n"
    "If a required parameter is omitted by the user, DO NOT guess or hallucinate the parameter; "
    "instead, formulate a concise, direct clarification query terminating with a question mark ('?').\n\n"
    f"Available Tools:\n{json.dumps(tools, indent=2)}"
)

# Case 1: Complete query
messages_complete = [
    {"role": "system", "content": system_prompt},
    {"role": "user", "content": "Retrieve the 60-minute volume_vwap metric for asset 'URAI-ALPHA'."}
]
prompt_1 = tokenizer.apply_chat_template(messages_complete, tokenize=False, add_generation_prompt=True)
print(generate(model, tokenizer, prompt=prompt_1, max_tokens=256, temp=0.0))

# Expected Output:
# ```json
# {
#   "name": "query_timeseries_metric",
#   "arguments": {
#     "asset_id": "URAI-ALPHA",
#     "metric_name": "volume_vwap",
#     "window_minutes": 60
#   }
# }
# ```

# Case 2: Incomplete query (missing metric_name)
messages_incomplete = [
    {"role": "system", "content": system_prompt},
    {"role": "user", "content": "Retrieve the timeseries metric for asset 'URAI-ALPHA'."}
]
prompt_2 = tokenizer.apply_chat_template(messages_incomplete, tokenize=False, add_generation_prompt=True)
print(generate(model, tokenizer, prompt=prompt_2, max_tokens=256, temp=0.0))

# Expected Output:
# Which metric_name (such as 'volume_vwap' or 'latency_p99') would you like to query for asset 'URAI-ALPHA'?

Quantized Variants & Memory Specifications

Uraion Forge 2B MLX is provided in multiple quantization formats to optimize for available Unified RAM:

Strict Privacy & Proprietary Safeguards

Uraion Labs enforces a rigorous boundary between open-source research and proprietary production infrastructure:

• 100% Local Sovereign Compute: All model operations, prompt tokens, tool outputs, and KV caches remain strictly within your Mac's physical Unified Memory. No telemetry, no external callbacks.
• Strict Boundary on Quantitative Alpha: Uraion Forge 2B was post-trained exclusively on public synthetic code, open standard benchmarks, and structural API interfaces. No proprietary trading alpha, internal quantitative execution strategies, order flow telemetry, or confidential financial datasets are contained within this model.

Citation & Organization

If you use Uraion Forge 2B or the MLX release in your research, edge deployments, or autonomous agent frameworks, please cite:

@misc{uraionlabs2026forge2bmlx,
  title={Uraion Forge 2B: Apple Silicon MLX Native Reasoning and Autonomous Agentic Tool Inference at the Edge},
  author={{Uraion Labs Technical Team}},
  year={2026},
  howpublished={\url{https://huggingface.co/uraionlabs/uraion-forge-2b-mlx}},
  note={Uraion Labs Open Source Release}
}

Official Website: https://uraionlabs.com
Hugging Face Organization: https://huggingface.co/uraionlabs
Main Model Repository: uraionlabs/uraion-forge-2b

Fabric workflow example

Watch a checked maintenance change in Uraion Fabric: an isolated Agent Workspace, executable checks, human Review and Apply.

This synthetic source-build demonstration uses qwen3.8:27b-nvfp4 through local Ollama, not Forge. It is not evidence of this model's performance, a customer outcome, or a signed public beta. The product page explains current limitations, local/cloud data flow and the proposed paid-pilot scope; pricing remains a hypothesis and inference is separate.