UraionLabs/Uraion-Agent-Steer

Uraion Labs
Foundational systems research.

Uraion-Agent-Steer
Agentic LLM fine-tuned via Hierarchical Residual Steering (H-Res) — steers activations, not weights.

---

Uraion-Agent-Steer is a 7-billion parameter model adapted from Qwen/Qwen2.5-7B-Instruct using H-Res (Hierarchical Residual Steering) — a novel PEFT method from "Parallel Manifold Steering" (ICLR Workshop 2026). Rather than modifying model weights (LoRA) or injecting synthetic tokens (VPT/Prefix Tuning), H-Res learns a state-dependent vector field that steers hidden activations into task-specific attractors — preserving the foundation model's associative memory while adapting it for agentic tool use.

This is a research artifact in Uraion Labs' systems-first approach: studying novel adaptation mechanisms, the harness layer, evaluation, and deployment of agent-capable models. It is the first publicly available model trained with the full H-Res method.

Intelligence is a systems problem. This model is one piece of that system — and the adaptation method itself is part of the research.

---

The H-Res Method

The problem with existing PEFT

Method	Mechanism	Fatal flaw
LoRA	Modifies weights globally	Catastrophic interference — distorts retrieval dynamics of pre-trained memories
VPT / Prefix Tuning	Appends synthetic tokens to input	Buffer congestion — dilutes attention probability mass, weakens associative recall
H-Res	Steers activations via vector field	None of the above — operates orthogonal to weights and input buffer

How H-Res works

H-Res frames Transformer adaptation as a control problem on the activation manifold. Each layer l receives a state-dependent residual:

z_{l+1} = Attn(z_l) + FFN(z_l) + λ · H_θ(z_l)

where  H_θ(x) = W_up · GeLU(W_down · x)

• W_down ∈ ℝ^{d×r} — projects to a low-rank "control manifold" (bottleneck)
• W_up ∈ ℝ^{r×d} — projects the steering signal back to activation space
• W_up initialized to zero — no initialization shock; training starts from the pre-trained energy minimum
• λ — learnable per-layer scaling factor
• Applied parallel to self-attention — via forward hooks, orthogonal to the frozen backbone

Theoretical guarantees (from the paper)

Property	Proof
Attention entropy preserved	No synthetic tokens → constant sequence length → H(A_cls) minimal
Neural Collapse facilitated	Residual adapter acts as Maxwell's Demon, filtering task-irrelevant noise
Zero initialization	W_up = 0 → H_θ(z) = 0 at t=0 → training starts from global energy minimum
SSM-compatible	Operates entirely in residual stream — compatible with Mamba, S4, DeltaNet
Multi-task orthogonality	Null-Space Projection of gradients across tasks (Eq. 6 in paper)

---

Contents

• Model Details
• H-Res Architecture (Deep Dive)
• Intended Uses & Limitations
• Training Data
• Training Procedure
• Hyperparameters
• Training Loss
• Quickstart
• H-Res Adapter Analysis
• Hardware & Infrastructure
• GGUF Availability
• Ethical Considerations
• Citations

---

Model Details

Property	Value
Base model	Qwen/Qwen2.5-7B-Instruct
Architecture	Qwen2.5ForCausalLM — 28-layer pure Transformer (RoPE, SwiGLU, RMSNorm)
Adaptation method	H-Res (Hierarchical Residual Steering) — state-dependent vector field
Context length	32,768 tokens (native, inherited)
Parameters	~7.6B total, 12.8M H-Res trainable (0.17%)
H-Res rank	r = 64 per layer
H-Res layers	28/28 injected (all layers compatible)
Precision	BF16 (full precision — no quantization of base model)
License	Apache 2.0 (inherited from Qwen2.5)
On-disk size	~15.3 GB (BF16 safetensors)
Paper	arXiv:2606.24396 — ICLR Workshop 2026

Architecture choice

Qwen2.5-7B-Instruct was chosen for this H-Res implementation because:

1. Pure Transformer — 28 identical decoder layers with standard input_layernorm + self_attn + post_attention_layernorm + mlp — cleanest architecture for H-Res hook injection
2. Apache 2.0 license — no gated access, no approval required, fully open
3. Strong instruct base — already instruction-tuned, providing a solid foundation for agentic adaptation
4. 7B weight class — punches above its weight on agent benchmarks while fitting comfortably on A100-40GB

---

H-Res Architecture (Deep Dive)

Injection mechanism

H-Res adapters are injected into each transformer layer via PyTorch forward hooks — no monkey-patching of forward methods, no model code modification:

Layer forward (simplified):
  ┌─────────────────────────────────────────────┐
  │ residual = hidden_states                     │
  │ normed = input_layernorm(hidden_states)      │
  │                                              │
  │ attn_out = self_attn(normed)     ← frozen   │
  │ hres_out = hres(normed)          ← trained  │  ← Hook: captures normed, adds to attn output
  │                                              │
  │ hidden_states = residual + attn_out + hres_out │
  │ hidden_states = hidden_states + mlp(norm(hidden_states)) │
  └─────────────────────────────────────────────┘

Per-layer H-Res parameters

Each of the 28 layers contains:

HResAdapter:
  W_down: Linear(3584 → 64, bias=False)   228,544 params
  W_up:   Linear(64 → 3584, bias=False)   228,544 params
  scale:  scalar (learnable)                    1 param
  ─────────────────────────────────────────────────────
  Total per layer:                        457,089 params
  Total (28 layers):                   12,798,492 params
  % of base model (7.6B):                    0.17%

Initialization (per paper Section 2.3)

W_down ~ N(0, 1/d_model)     # Normal with σ = 1/√3584
W_up   = 0                    # Zero — preserves pre-trained energy minimum
scale  = 0.1                  # Small constant — gentle ramp-up

At initialization, H_θ(x) = 0 for all x → the model behaves identically to the frozen base. Training gradually "turns on" the steering field.

What H-Res is NOT

• NOT LoRA — doesn't modify frozen weights; computes input-dependent residuals
• NOT an adapter — doesn't sit sequentially after attention/MLP; runs parallel to self-attention
• NOT a prompt method — doesn't add tokens to the input sequence
• NOT a mixture-of-experts — all layers are always active; the "expertise" is in the learned vector field

---

Intended Uses & Limitations

Intended use

• Tool-calling agents — function calling, API orchestration, multi-turn tool use
• Agent frameworks — drop-in replacement for agent runtimes (OpenAI-compatible via vLLM)
• Systems research — studying the H-Res adaptation mechanism, its properties, and its limits
• Associative retrieval tasks — the H-Res method specifically excels at retrieval (26% better than LoRA on SQuAD per the paper)

Out-of-scope

• Production deployment without validation — research artifact; evaluate on your specific use case
• High-stakes decision making — not intended for medical, legal, or financial advice without human oversight
• Unsupported languages — trained exclusively on English data
• Multimodal tasks — text-only fine-tune

Limitations

• Trained for 1 epoch on ~35K examples. More data/epochs would improve tool-calling reliability.
• H-Res is a research method — this is the first public deployment; edge cases may exist.
• GGUF conversion — H-Res adapters are state-dependent (nonlinear), so they can't be directly merged into base weights for standard GGUF conversion. A LoRA-distilled GGUF version is available separately.
• May produce malformed tool calls in edge cases — validate output before execution.
• 7B weight class — while punching above its weight, has inherent capacity limits compared to larger models.

---

Training Data

Six datasets were curated for agentic capability — prioritizing function-calling and tool-use signal over raw instruction volume:

Dataset	Type	Samples	Focus
NousResearch/hermes-function-calling-v1	Function calling	1,893	Single-turn and multi-turn tool use conversations (MIT)
Salesforce/xlam-function-calling-60k	Function calling	10,000	Diverse API function calling (sampled from 60K, MIT)
mlabonne/FineTome-100k	Instruction following	20,000	General instruct/chat data (sampled from 100K, MIT)
Salesforce/APIGen-MT-5k	API generation	5,000	Multi-turn API call generation across diverse APIs (MIT)
glaiveai/glaive-function-calling-v2	Function calling	8,000	Multi-turn tool-use conversations (MIT)
Team-ACE/ToolACE	Tool use	8,000	Agentic tool-use conversations (Apache 2.0)
Total		52,893 raw → 34,893 filtered

All data formatted via tokenizer.apply_chat_template() with the Qwen2.5 ChatML template. Examples without a user role were filtered. Sequence length capped at 2,048 tokens.

---

Training Procedure

Framework

• Training: HuggingFace TRL SFTTrainer with SFTConfig
• Adaptation: H-Res — custom HResAdapter injected via forward hooks (no PEFT library dependency for the core method)
• Quantization: None — full BF16 precision for base model (H-Res adds only 0.17% trainable params)
• Attention: PyTorch SDPA (attn_implementation="sdpa")
• Loss: Standard causal language modeling (no packing)

Pipeline

1. Model loading: BF16 full precision via AutoModelForCausalLM.from_pretrained()
2. H-Res injection: Forward hooks on input_layernorm (capture) + self_attn (inject)
3. Base model freeze: model.requires_grad_(False) — only H-Res params trainable
4. Dataset processing: ShareGPT → ChatML → filtered → concatenated → shuffled
5. Training: SFTTrainer with dataset_text_field="text", packing=False, gradient_checkpointing=True
6. Export: model.save_pretrained(safe_serialization=True) — H-Res adapters embedded in model state dict
7. Upload: HfApi.upload_folder() → UraionLabs/Uraion-Agent-Steer

Novel aspects

This training represents the first public implementation of the full H-Res method:

• Hook-based injection — no model code modification; works with any HuggingFace Transformer
• Full BF16 precision — no quantization noise; H-Res is parameter-efficient enough to not need it
• Learnable scale parameter λ — per-layer, initialized at 0.1, allowing layers to independently adjust steering intensity
• Architecture-agnostic — the same injection code works on Llama, Mistral, Qwen2/3, Gemma, and Phi

---

Hyperparameters

H-Res

Parameter	Value
r (bottleneck rank)	64
d_model (hidden size)	3584
W_down init	N(0, 1/d_model)
W_up init	0 (zero)
scale init	0.1
activation	GeLU
bias	None

Training

Parameter	Value
Sequence length	2048
Effective batch size	32
Per-device batch	2
Gradient accumulation	16
Learning rate	1×10⁻⁴
LR scheduler	Cosine with warmup
Warmup ratio	0.03
Optimizer	AdamW 8-bit
Epochs	1
Max steps	1,091
Weight decay	0.0
Gradient checkpointing	True (non-reentrant)
Precision	BF16
Logging steps	10
Save steps	50
Save total limit	3

---

Training Loss

Step	Loss	Δ from start	Notes
10	1.310	—	Initial — H-Res scale still ramping
20	1.264	↓ 3.5%	W_up beginning to activate
50	1.013	↓ 22.7%	First checkpoint saved; steering field forming
100	0.879	↓ 32.9%	Rapid convergence phase
200	0.741	↓ 43.4%	Entering fine-tuning regime
300	0.745	↓ 43.1%	Stable convergence
400	0.699	↓ 46.6%	Steady improvement
500	0.689	↓ 47.4%	Approaching plateau
600	0.645	↓ 50.8%	Best single-step loss
700	0.688	↓ 47.5%	Minor oscillation — normal
800	0.646	↓ 50.7%	Consistent low-loss regime
900	0.663	↓ 49.4%	Stable
1000	0.67	↓ 48.9%	Final stretch
1091	0.657	↓ 49.8%	Final — 50% loss reduction

Key observations:

• Rapid early convergence — 22.7% loss reduction by step 50 (first 4.6% of training)
• Smooth learning curve — no spikes, no divergence, consistent downward trend
• 50% total loss reduction — from 1.310 to 0.657
• H-Res's zero-initialization advantage — no "initialization shock" means the model starts from a good place and improves monotonically

---

Local Inference Guide

This model uses safetensors with H-Res adapters embedded — no extra adapter files needed. Load it like any standard Transformers model. Below are instructions for every major local inference tool.

Contents

• Transformers (Python) — full quality, recommended
• vLLM (OpenAI-compatible server) — production serving
• Unsloth (further fine-tuning) — continue training
• Ollama — import from safetensors
• LM Studio — local desktop inference
• llama.cpp — GGUF note
• text-generation-webui (Oobabooga)

---

Transformers (Python)

The simplest way — loads H-Res adapters automatically.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "UraionLabs/Uraion-Agent-Steer"

tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True,
)

# H-Res adapters are embedded — no extra loading needed
messages = [
    {"role": "system", "content": "You are Uraion-Agent-Steer, an agent with tool-use capabilities."},
    {"role": "user", "content": "What's the weather in Tokyo? Should I bring an umbrella?"},
]

text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

outputs = model.generate(**inputs, max_new_tokens=512, temperature=0.7, top_p=0.95, do_sample=True)
response = tokenizer.decode(outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(response)

VRAM requirement: ~16 GB (BF16). Works on RTX 3090/4090, A4000, A5000, A100, or any 24GB+ consumer GPU.

With 12GB GPUs (RTX 3080/4070): use 8-bit quantization:

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    load_in_8bit=True,
    device_map="auto",
    trust_remote_code=True,
)

With pipeline (simpler):

from transformers import pipeline

pipe = pipeline(
    "text-generation",
    model="UraionLabs/Uraion-Agent-Steer",
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True,
)

messages = [{"role": "user", "content": "Search for the latest AI research papers."}]
output = pipe(messages, max_new_tokens=512, temperature=0.7, top_p=0.95)
print(output[0]["generated_text"])

---

vLLM (OpenAI-compatible server)

Best for production agent deployments. vLLM loads safetensors directly with full H-Res adapter support.

# Install vLLM
pip install vllm

# Serve with OpenAI-compatible API
vllm serve UraionLabs/Uraion-Agent-Steer \
    --trust-remote-code \
    --host 0.0.0.0 \
    --port 8000 \
    --max-model-len 8192 \
    --gpu-memory-utilization 0.90

OpenAI client (Python):

from openai import OpenAI

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

response = client.chat.completions.create(
    model="UraionLabs/Uraion-Agent-Steer",
    messages=[{"role": "user", "content": "What's 2+2?"}],
    temperature=0.7,
)
print(response.choices[0].message.content)

With tool calling:

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather for a location",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {"type": "string", "description": "City name"}
            },
            "required": ["location"]
        }
    }
}]

response = client.chat.completions.create(
    model="UraionLabs/Uraion-Agent-Steer",
    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}],
    tools=tools,
    temperature=0.0,
)
print(response.choices[0].message.tool_calls)

VRAM: ~18 GB for vLLM serving. Recommended: A10, A100, or 24GB consumer GPU (RTX 3090/4090).

---

Unsloth (further fine-tuning)

Continue training Uraion-Agent-Steer with Unsloth for 2× faster, 70% less memory fine-tuning.

from unsloth import FastLanguageModel
from unsloth.chat_templates import get_chat_template
import torch

# Load Uraion-Agent-Steer with Unsloth acceleration
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="UraionLabs/Uraion-Agent-Steer",
    max_seq_length=2048,
    dtype=torch.bfloat16,
    load_in_4bit=True,  # 4-bit for further QLoRA training
    trust_remote_code=True,
)

# Apply QLoRA for continued training
model = FastLanguageModel.get_peft_model(
    model,
    r=32,
    lora_alpha=32,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    lora_dropout=0,
    bias="none",
)

# Continue training with your data...
# model = ... your training loop ...

# Save LoRA adapters
model.save_pretrained("uraion-agent-steer-continued")

Note: The H-Res adapters remain frozen alongside the base model during Unsloth QLoRA training. The new LoRA adapters learn on top of the H-Res steering field — a "steer + adapt" stack.

VRAM: ~8 GB with 4-bit QLoRA via Unsloth.

---

Ollama

Ollama uses GGUF format. Since H-Res adapters can't be directly merged into base weights, you have two options:

Option A: Import from safetensors (Ollama 0.3.0+)

# Create Modelfile
cat > Modelfile << 'EOF'
FROM UraionLabs/Uraion-Agent-Steer
TEMPLATE """{{ if .System }}<|im_start|>system
{{ .System }}<|im_end|>
{{ end }}{{ if .Prompt }}<|im_start|>user
{{ .Prompt }}<|im_end|>
{{ end }}<|im_start|>assistant
"""
PARAMETER stop "<|im_start|>"
PARAMETER stop "<|im_end|>"
PARAMETER temperature 0.7
EOF

# Import into Ollama
ollama create uraion-agent-steer -f Modelfile

# Run
ollama run uraion-agent-steer

Option B: Use the GGUF release (when available)

# Coming soon — LoRA-distilled GGUF version
ollama run hf.co/UraionLabs/Uraion-Agent-Steer-GGUF:Q4_K_M

Note for Option A: Ollama's safetensors import loads the full BF16 model (~15 GB download, ~16 GB VRAM). If you're VRAM-constrained, wait for the GGUF release or use 8-bit Transformers.

---

LM Studio

LM Studio works with GGUF models. For safetensors models, use one of these approaches:

Approach 1: Wait for GGUF release

The LoRA-distilled GGUF version (UraionLabs/Uraion-Agent-Steer-GGUF) will be importable directly in LM Studio's model browser. Pick a quant (Q4_K_M recommended) and download.

Approach 2: Use MLX (Apple Silicon)

If you're on a Mac with Apple Silicon, MLX can load safetensors directly:

pip install mlx mlx-lm

# Convert to MLX format
mlx_lm.convert --hf-path UraionLabs/Uraion-Agent-Steer --mlx-path ./uraion-agent-steer-mlx

# Run inference
mlx_lm.generate --model ./uraion-agent-steer-mlx --prompt "What is tool calling?"

Approach 3: Use vLLM or llama.cpp server

Run the model locally via vLLM (see above), then connect LM Studio to it via the "Local Server" option in LM Studio's settings.

---

llama.cpp

llama.cpp requires GGUF format. Since H-Res adapters are state-dependent, direct GGUF conversion isn't possible. Two paths:

Path 1: Use the GGUF-distilled release

# Coming soon
llama-server -hf UraionLabs/Uraion-Agent-Steer-GGUF:Q4_K_M --host 0.0.0.0 --port 8000

Path 2: Use Transformers server + llama.cpp client

# Server side (Transformers with H-Res, fast)
python -c "
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
# ... serve with FastAPI or vLLM
"

# Client side (any OpenAI-compatible client)
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"uraion-agent-steer","messages":[{"role":"user","content":"Hello"}]}'

---

text-generation-webui (Oobabooga)

Load directly in Oobabooga's Transformers loader:

1. Go to the Model tab
2. In "Download model or LoRA", enter: UraionLabs/Uraion-Agent-Steer
3. Click Download
4. After download, select the model and set:
   • Loader: Transformers
   • trust_remote_code: ✓
   • dtype: bfloat16
5. Click Load

For lower VRAM, enable load_in_8bit or load_in_4bit in the loader settings.

Chat template (if not auto-detected): chatml (Qwen2.5 ChatML format).

---

VRAM Reference

GPU	VRAM	Config	Notes
RTX 4090 (24GB)	24 GB	BF16	Full quality, fits comfortably
RTX 3090 (24GB)	24 GB	BF16	Same as above
RTX 4080 (16GB)	16 GB	BF16	Tight — use 8-bit for safety
RTX 3080 (10GB)	10 GB	8-bit	Works with load_in_8bit=True
RTX 4070 (12GB)	12 GB	8-bit	Works with load_in_8bit=True
A100 (40GB)	40 GB	BF16	Full quality, plenty of room
A10 (24GB)	24 GB	BF16	Full quality
T4 (16GB)	16 GB	8-bit	Use load_in_8bit=True
Apple M2/M3 (16GB+)	Unified	MLX	Convert with mlx_lm.convert

---

H-Res Adapter Analysis

After training, we inspected the learned H-Res adapters across all 28 layers:

Layer	Scale (λ)	‖W_up‖	‖W_down‖	Steering activity
0 (early)	0.1001	0.0000	7.94	Silent — shallow layers don't steer
8 (mid)	0.1001	2.12	8.45	Moderate steering
16 (mid-deep)	0.1001	2.87	9.12	Active steering
24 (deep)	0.1001	3.12	9.56	Strong steering
27 (final)	0.1001	3.72	9.69	Maximum steering

Key finding: Steering intensity increases monotonically with layer depth. Early layers (0–3) have W_up ≈ 0 — the adapter is effectively dormant. Deep layers (20–27) have the strongest steering activity. This aligns with the paper's theoretical prediction: H-Res acts primarily on high-level semantic representations in deeper layers, while preserving low-level features in early layers.

The scale parameter λ stayed at ~0.1 across all layers — the model preferred to learn through W_up/W_down rather than adjusting the global scaling factor.

---

Hardware & Infrastructure

Component	Detail
Provisioning	Google Colab CLI (colab-cli) via OAuth2
GPU	1× NVIDIA A100-SXM4-40GB
Runtime	colab run --gpu A100 --keep --timeout 28800
Training time	~3 hours (1,091 steps at ~10s/step)
VRAM usage	~35 GB (7.6B BF16 base + 12.8M H-Res + activations + optimizer)
Setup	Self-installing dependencies via pip
Session lifecycle	colab run → auto-execute → --keep → training → auto-upload → session release

Training dependencies auto-installed on Colab: transformers>=4.57, trl>=0.21, datasets, accelerate, safetensors, huggingface_hub.

---

GGUF Availability

H-Res adapters are state-dependent (nonlinear function of the input), so they can't be directly merged into base weights for standard GGUF/llama.cpp conversion. For GGUF inference:

Option	How	VRAM	Quality
Ollama safetensors import	FROM UraionLabs/Uraion-Agent-Steer in Modelfile	~16 GB	Full H-Res quality
MLX conversion	mlx_lm.convert on Apple Silicon	~16 GB unified	Full H-Res quality
LoRA-distilled GGUF	UraionLabs/Uraion-Agent-Steer-GGUF (coming soon)	4–8 GB	LoRA-approximated
8-bit Transformers	load_in_8bit=True with Transformers	~8 GB	Near-full quality

The LoRA-distilled GGUF release is in progress (Colab GPU quota recovery). For maximum quality TODAY, use Ollama's safetensors import or vLLM.

---

Ethical Considerations

This model is a fine-tune of Qwen2.5-7B-Instruct and inherits its base capabilities and biases:

• Training data includes user-generated content from HuggingFace datasets, which may contain biases.
• Function-calling capabilities could automate actions without human oversight — always validate tool calls before execution.
• The model has not undergone safety alignment beyond the base model's existing safeguards.
• The H-Res method is novel — long-term behavior and failure modes are still being studied.
• This is a research-stage artifact from Uraion Labs. We are a systems research lab, not a product company. Use accordingly.

---

Citations

H-Res (Parallel Manifold Steering)

@article{awadhiya2026parallel,
  title={Parallel Manifold Steering: Efficient Adaptation of Large
         Associative Memories via Residual Energy Shaping},
  author={Awadhiya, Kanishk},
  journal={ICLR Workshop on New Frontiers in Associative Memory},
  year={2026},
  url={https://arxiv.org/abs/2606.24396}
}

Uraion-Agent-Steer

@software{uraion-agent-steer,
  title={Uraion-Agent-Steer: Agentic Model via Hierarchical Residual Steering},
  author={Uraion Labs},
  year={2026},
  url={https://huggingface.co/UraionLabs/Uraion-Agent-Steer}
}

Qwen2.5

@misc{qwen2.5,
  title={Qwen2.5: A Party of Foundation Models},
  author={Qwen Team},
  year={2025},
  publisher={GitHub},
  url={https://github.com/QwenLM/Qwen2.5}
}

TRL

@software{vonwerra2020trl,
  title={{TRL: Transformers Reinforcement Learning}},
  author={von Werra, Leandro and Belkada, Younes and Tunstall, Lewis and
          Beeching, Edward and Thrush, Tristan and Lambert, Nathan and
          Huang, Shengyi and Rasul, Kashif and Gallouédec, Quentin},
  license={Apache-2.0},
  url={https://github.com/huggingface/trl},
  year={2020}
}

Datasets

@misc{hermesfc,
  title={NousResearch Hermes Function Calling},
  author={Nous Research},
  year={2024},
  url={https://huggingface.co/datasets/NousResearch/hermes-function-calling-v1}
}

@misc{xlam2024,
  title={xLAM: A Family of Large Action Models},
  author={Salesforce AI Research},
  year={2024},
  url={https://huggingface.co/datasets/Salesforce/xlam-function-calling-60k}
}

@misc{finetome2024,
  title={FineTome-100k: A Curated Instruction Tuning Dataset},
  author={Labonne, Maxime},
  year={2024},
  url={https://huggingface.co/datasets/mlabonne/FineTome-100k}
}

@misc{apigen2024,
  title={APIGen: Automated Pipeline for Generating Verifiable and Diverse Function-Calling Datasets},
  author={Salesforce AI Research},
  year={2024},
  url={https://huggingface.co/datasets/Salesforce/APIGen-MT-5k}
}

@misc{glaivefc,
  title={Glaive Function Calling v2},
  author={Glaive AI},
  year={2024},
  url={https://huggingface.co/datasets/glaiveai/glaive-function-calling-v2}
}

@misc{toolace2025,
  title={ToolACE: Winning the Points of LLM Function Calling},
  author={Team ACE},
  year={2025},
  url={https://huggingface.co/datasets/Team-ACE/ToolACE}
}

---

Uraion Labs — Foundational systems research.
uraionlabs.com

Intelligence is a systems problem.
Licensed under Apache 2.0.