Instructions to use alwkala/Aton with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use alwkala/Aton with Transformers:

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

pipe = pipeline("text-generation", model="alwkala/Aton")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("alwkala/Aton")
model = AutoModelForMultimodalLM.from_pretrained("alwkala/Aton", device_map="auto")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
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=256)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

llama.cpp

How to use alwkala/Aton with llama.cpp:

Install (macOS, Linux)

curl -LsSf https://llama.app/install.sh | sh
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf alwkala/Aton:F16
# Run inference directly in the terminal:
llama cli -hf alwkala/Aton:F16

Install from WinGet (Windows)

winget install llama.cpp
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf alwkala/Aton:F16
# Run inference directly in the terminal:
llama cli -hf alwkala/Aton:F16

Build from source code

git clone https://github.com/ggml-org/llama.cpp.git
cd llama.cpp
cmake -B build
cmake --build build -j --target llama-app
# Start a local OpenAI-compatible server with a web UI:
./build/bin/llama serve -hf alwkala/Aton:F16
# Run inference directly in the terminal:
./build/bin/llama cli -hf alwkala/Aton:F16

Use Docker

docker model run hf.co/alwkala/Aton:F16

Llama new
LM Studio
Jan

vLLM

How to use alwkala/Aton with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/alwkala/Aton:F16

SGLang

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

Ollama
How to use alwkala/Aton with Ollama:
```
ollama run hf.co/alwkala/Aton:F16
```
Unsloth Desktop

How to use alwkala/Aton with Pi:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf alwkala/Aton:F16

Configure the model in Pi

# Install Pi:
npm install -g @earendil-works/pi-coding-agent
# Add to ~/.pi/agent/models.json:
{
  "providers": {
    "llama-cpp": {
      "baseUrl": "http://localhost:8080/v1",
      "api": "openai-completions",
      "apiKey": "none",
      "models": [
        {
          "id": "alwkala/Aton:F16"
        }
      ]
    }
  }
}

Run Pi

# Start Pi in your project directory:
pi

Docker Model Runner
How to use alwkala/Aton with Docker Model Runner:
```
docker model run hf.co/alwkala/Aton:F16
```

Lemonade

How to use alwkala/Aton with Lemonade:

Pull the model

# Download Lemonade from https://lemonade-server.ai/
lemonade pull alwkala/Aton:F16

Run and chat with the model

lemonade run user.Aton-F16

List all available models

lemonade list

Hermes Agent

How to use alwkala/Aton with Hermes Agent:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf alwkala/Aton:F16

Configure Hermes

# Install Hermes:
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
hermes setup
# Point Hermes at the local server:
hermes config set model.provider custom
hermes config set model.base_url http://127.0.0.1:8080/v1
hermes config set model.default alwkala/Aton:F16

Run Hermes

hermes

Atomic Chat

OpenClaw

How to use alwkala/Aton with OpenClaw:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf alwkala/Aton:F16

Configure OpenClaw

# Install OpenClaw:
npm install -g openclaw@latest
# Register the local server and set it as the default model:
openclaw onboard --non-interactive --mode local \
  --auth-choice custom-api-key \
  --custom-base-url http://127.0.0.1:8080/v1 \
  --custom-model-id "alwkala/Aton:F16" \
  --custom-provider-id llama-cpp \
  --custom-compatibility openai \
  --custom-text-input \
  --accept-risk \
  --skip-health

Run OpenClaw

openclaw agent --local --agent main --message "Hello from Hugging Face"

You need to agree to share your Hugging Face information to access this model

This repository is publicly accessible, but you have to accept the conditions to access its files and content.

Akhet-Aton-2B — Model Card & Documentation

Ultra-Lightweight Edge Agent & Multimodal Model by Alwkala Digital Labs

Part of the AkhetRa Ecosystem (Aton: Operational Intelligence · Akhet: Governance)

Status: Release v0.1.0 · Date: 2026-11-05
Base Model: Qwen/Qwen3.5-2B by Qwen
Fine-tuned & Quantized by: Alwkala Digital Labs
Model Type: Bilingual (Arabic/English) Edge Agent · Hybrid SSM + Attention + Optional CLIP Vision Tower
Deployment Focus: Local Inference, Private Edge Computing, and Modest Hardware
Active Distributions:

Language Model: Aton-2B-Q4_K_M.gguf (1.31 GB)
Vision Projector: Aton-2B-F16-mmproj.gguf (668 MB)
Hugging Face Repository: alwkala/Aton

1. Overview & Positioning

A 2 Billion parameter (2B) model has unique architectural advantages that make it exceptional for specific real-world tasks, rather than attempting to serve as an all-purpose encyclopedic oracle.

Akhet-Aton-2B is developed by Alwkala Digital Labs as a fast, private, and deterministic bilingual agent. Its strength is rooted in:

Speed & Low Latency: Rapid response generation ideal for real-time applications.
Low Hardware Footprint: Runs comfortably on laptops, modest GPUs (< 3 GB VRAM), and standard CPUs.
Complete Privacy: 100% local execution—zero telemetry or external data transfer.
High Task Determinism: High fidelity in structured JSON extraction, routing, and tool calling.

2. Core Use Cases

#	Use Case	Key Task	Advantage
1	Local Desktop Assistant	Local file management, document summarization, voice/text desktop actions	Air-gapped privacy (data never leaves the machine)
2	Triage & Routing Agent	Ingesting support tickets/emails, extracting metadata, dispatching APIs	Ultra-fast classification at near-zero operating cost
3	Data Parsing & Structuring	Ingesting invoices, receipts, and CVs (AR/EN) into strict JSON	High structural compliance without hallucination
4	IoT & Automation Orchestrator	Translating natural language to bash, python, or function calls	Low energy draw; persistent run on Raspberry Pi / Edge nodes
5	RAG Query Generator	Decomposing complex queries into 1–3 precise vector search queries	Boosts RAG precision without wasting compute on large LLMs
6	Offline Educational Drill	Conversational practice, grammar correction, bilingual translation	100% offline functionality for low-connectivity environments

3. Operational Boundaries & Anti-Patterns

Avoid Multi-Step Complex Reasoning: Not built for solving abstract mathematical problems or writing complex algorithms from scratch without external tooling.
Avoid Unbounded Long-Form Generation: Not intended for generating multi-thousand-word novels or lengthy essays where small models tend to drift.
Avoid Using as a Standalone Fact Oracle: Ground all factual Q&A with local RAG documents or search retrieval.

4. Technical Specifications

Field	Value / Specification
Model Name	Akhet-Aton-2B (Alias: `Aton-2B`)
Model Family	Akhet-Aton
Organization / Developer	Alwkala Digital Labs (alwkala.com)
Base Model	Qwen3.5 2B (`Qwen/Qwen3.5-2B`) by Qwen
Architecture	Hybrid SSM (Mamba-style) + Interleaved Attention + CLIP Vision Tower
Total Parameters	~ 2,231,000,000 (~ 2.23 Billion Parameters)
Language Parameters	~ 1,900,000,000 (~ 1.9 Billion Parameters)
Vision Parameters	~ 331,000,000 (~ 331 Million Parameters)
Vocabulary Size	248,320 tokens
SFT Trained Context	2,048 tokens (2K)
Base Native Context	262,144 tokens (256K Native Base Context)
Recommended Runtime Context	8,192 to 32,768 tokens (8K - 32K)
Vision Resolution	768 × 768 pixels (16×16 patch size)
Reasoning Mode	Native Chain-of-Thought (`<think>...</think>`)
Tool Calling Format	Native XML/JSON Tool Calling (`<tool_call>`, `<tool_response>`)
Base License	Apache-2.0
Quantization Format	GGUF Q4_K_M (Language: 1.31 GB) + F16 (Vision Projector: 668 MB)

5. Quick Start & Execution

5.1 Native GUI Studio

Launch the official desktop wizard Launch-Studio.bat with one-click hardware inspection and execution control.

5.2 Adaptive Multimodal Runner (Live TUI Dashboard)

# Launches the adaptive multimodal engine with live telemetry and tool support
.\run-Aton-Adaptive-tools.ps1 -Port 8080 -EngineMode Apex1

5.3 Raw llama-server Execution

llama-server.exe `
  -m ./Aton-2B-Q4_K_M.gguf `
  --mmproj ./Aton-2B-F16-mmproj.gguf `
  --image-min-tokens 1024 `
  --alias "Akhet-Aton-2B" `
  -ngl 99 `
  -c 8192 `
  -t 8 `
  --jinja `
  --flash-attn on `
  --tools all `
  --host 0.0.0.0 `
  --port 8080

Downloads last month: -

GGUF

Model size

2B params

Architecture

qwen35

Hardware compatibility

4-bit

Model tree for alwkala/Aton

Base model

Qwen/Qwen3.5-2B-Base

Finetuned

Qwen/Qwen3.5-2B

Finetuned

(673)

this model