alfinpratama/qwen38-27b-desktop-agent-lora

qwen38-27B-desktop-agent-lora

LoRA adapter for desktop-agent tool-calling on top of unsloth/Qwen3.8-27B-unsloth-bnb-4bit (4-bit QLoRA). Trains the model to act as an autonomous Linux desktop co-worker: reason, call tools, observe results, recover from errors, and stop when no tool is needed.

Research prototype for a multimodal autonomous desktop agent (voice/vision + tool use). Not a general chat upgrade.

Model Details

• —Base model: unsloth/Qwen3.8-27B-unsloth-bnb-4bit (Qwen3.5 architecture, Qwen3_5ForConditionalGeneration, hybrid Gated DeltaNet + Gated Attention, native 262k context)
• —Adapter type: LoRA (PEFT 0.18.1), r=16, lora_alpha=16, lora_dropout=0.0, bias=none
• —Target modules: q_proj, k_proj, v_proj, o_proj, gate_proj, up_proj, down_proj (full-attention + MLP)
• —Trainable: ~80M / 27.4B (~0.29%)
• —Quantization: bnb-4bit (NF4 + double quant), bf16 compute
• —Task: CAUSAL_LM, supervised fine-tuning for tool-calling
• —Languages: English (tool schemas + reasoning in English)
• —License: Follows base model license. Check Qwen / Unsloth terms before commercial use.

Intended Use

Direct Use

OpenAI-compatible chat with tools + tool_calls. System message carries tool JSON schemas. Assistant responds with <think>reasoning</think> plus native <tool_call> blocks, or a final answer when no tool is needed.

Supported tool families (client-dependent):

• —execute_command, read_file, write_file
• —open_application, open_browser, navigate_browser
• —git_operation, run_test
• —press_key, type_text, take_screenshot, inspect_screen

Exact tool list is defined by the client. This adapter only decides when and how to call them.

Downstream Use

• —Linux desktop agent / SWE agent backends
• —Merged LoRA + base for single-weight deployment
• —Further fine-tuning on private desktop workflows

Out-of-Scope Use

• —General knowledge chatbot, medical/legal advice, high-stakes decisions
• —Autonomous destructive actions without a client-side whitelist / approval layer
• —Vision grounding beyond what the client supplies as image_url

Training Data

~9,200 deduplicated multi-turn samples, formatted with the native Qwen chat_template.jinja:

Each sample: system (instructions + tool schemas) + conversations (user / assistant with reasoning_content + tool_calls / tool observation / final answer).

Training Procedure

• —Stack: Unsloth + TRL SFTTrainer + PEFT + Transformers 5.x
• —Hardware: single AMD MI300X (192 GB), ROCm
• —Precision: bf16, optimizer adamw_8bit, gradient checkpointing (Unsloth)
• —Batch: per-device 4, grad-accum 2 (effective 8)
• —Epochs: 3, total ~2,991 steps
• —Loss trajectory: ~4.3 at start → near-zero at end of run
• —Checkpoints every 20 steps, final adapter saved as adapter_model.safetensors + tokenizer files

Note on low final loss: offline qualitative eval showed contextual reasoning (defensive mkdir before write, status-before-commit, clarifying ambiguous requests) rather than pure memorization, but no formal benchmark is claimed here.

Evaluation

Qualitative post-training check, 6 scenarios, all passed:

1. 1.Schema faithfulness (correct param names)
2. 2.Unseen tool (new schema at inference, multi-hop resolve)
3. 3.Multi-step workflow (write then verify)
4. 4.Git lifecycle on new context (status before commit)
5. 5.Negative case (chat-only, no spurious tool call)
6. 6.Ambiguous request (asks for clarification instead of guessing)

No quantitative benchmark (SWE-bench, BFCL, etc.) is reported. Treat accuracy numbers as unevaluated until a formal eval is published.

How to Use

Install (Colab: restart session after install so bitsandbytes native lib loads):

pip install -U "bitsandbytes>=0.46.1" transformers peft accelerate

Inference (4-bit base + LoRA, Transformers 5.x API):

from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
from peft import PeftModel
import torch

base_id = "unsloth/Qwen3.8-27B-unsloth-bnb-4bit"
adapter_id = "alfinpratama/qwen38-27b-desktop-agent-lora"

# Qwen3.8 processor wraps text tokenizer; use inner tokenizer for text-only
tok = AutoTokenizer.from_pretrained(adapter_id, trust_remote_code=True)
text_tok = getattr(tok, "tokenizer", tok)

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_use_double_quant=True,
    bnb_4bit_compute_dtype=torch.bfloat16,
)

model = AutoModelForCausalLM.from_pretrained(
    base_id,
    quantization_config=bnb_config,
    dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True,
)
model = PeftModel.from_pretrained(model, adapter_id)
model.eval()

tools = [{
    "name": "execute_command",
    "description": "Run an allowlisted shell command",
    "parameters": {"type": "object",
        "properties": {"command": {"type": "string"}},
        "required": ["command"]},
}]

messages = [
    {"role": "system", "content": "You are a desktop agent. Call tools when needed, otherwise answer directly."},
    {"role": "user", "content": "Check today's date via shell."},
]

prompt = text_tok.apply_chat_template(
    messages, tools=tools, tokenize=False, add_generation_prompt=True
)
inputs = text_tok(prompt, return_tensors="pt").to(model.device)

out = model.generate(**inputs, max_new_tokens=256, temperature=0.1, do_sample=True)
print(text_tok.decode(out[0], skip_special_tokens=False))

For serving, merge or load via any OpenAI-compatible server that supports PEFT adapters and exposes tools / tool_calls as JSON. Native <tool_call> XML must be parsed to OpenAI delta.tool_calls server-side.

Bias, Risks, and Limitations

• —Research adapter, narrow domain. May mis-select tools or hallucinate params outside training distribution.
• —Low-data regime for desktop workflows (500 synthetic + public shell pairs). Expect variance on unseen apps.
• —No safety filter inside weights. Enforce a client-side whitelist (allowed paths / commands) and require confirmation for destructive, privileged, or exfiltrating actions.
• —Vision understanding comes from base model; this adapter was trained text-only for tool-calling.
• —27B 4-bit needs ~20-25 GB VRAM. Colab free T4 (16 GB) will OOM; use A100 or larger.

Environmental Impact

• —Single-GPU QLoRA run, a few hours wall-clock. Exact kWh / CO2eq not tracked.