GLM-5.3 is live. Run Z.ai's latest model on Friendli Model APIs. Try it today ➜
wxsys
Available on FriendliAI
Run this model inference on single tenant GPU with unmatched speed and reliability at scale.
Model Details
Model Provider
wxsys
Model Tree
Qwen/Qwen3.5-0.8B-Base
Input Modalities
Output Modalities
Supported Functionality
Qwen-Servitor is a headless neural decision engine designed for automated pull request review, pre-commit gating, and static code security triage. It operates as the fast, lightweight component in the Servitor family, complementing the larger wxsys/spark-servitor (1.7B, Sliding Window Attention, 1M context).
Where Spark-Servitor provides deep multi-file receptive capacity for massive monorepos, Qwen-Servitor is optimized for speed and minimal memory footprint. Built upon the hybrid backbone of Qwen3.5-0.8B (18 Gated DeltaNet layers and 6 Full Attention layers), the 155M-parameter generative projection layer (lm_head) is excised. Hidden states route directly into a multi-task neural judgment cortex that outputs structured verdicts, calibrated risk scores, pathology tags, and exploit flows in a single forward evaluation pass.
text
[ RAW DIFF / 262K TOKEN CONTEXT ] │ ▼ ┌─────────────────────────────────────────────────────────────┐ │ QWEN 3.5 HYBRID NEURAL SPINE │ │ • 18x Gated DeltaNet Layers (O(1) Recurrent State) │ │ • 6x Gated Full Attention Layers (Global Context) │ │ • HySparse2 Cross-Layer KV Sharing (33% GEMM Reduction) │ │ • AST-Landmark Eviction (Caps attention cache at 4k tokens│ │ • 155M-parameter Generative Head: EXCISED / REMOVED │ └─────────────────────────────────────────────────────────────┘ │ [ Final Hidden State (h_T) ] │ ▼ ┌─────────────────────────────────────────────────────────────┐ │ LATENT RECURRENT PONDERING (k = 1..4) │ │ • Internal recurrence loop without token emission │ │ • Early halting at confidence threshold p_halt >= 0.95 │ └─────────────────────────────────────────────────────────────┘ │ ┌────────────────────────┼────────────────────────┐ ▼ ▼ ▼ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ │ VERDICT HEAD │ │ RISK HEAD │ │ PATHOLOGY HEAD│ │ 3-Way Output │ │ Sigmoid(1) │ │ 8-Class Multi │ │ • APPROVE │ │ Continuous │ │ • SECURITY │ │ • QUARANTINE │ │ Risk Score │ │ • DEADLOCK │ │ • REJECT │ │ (0.00-1.00) │ │ • PERF_COLLAP │ └───────┬───────┘ └───────────────┘ └───────────────┘ │ ▼ (If QUARANTINE: Formal Neuro-Symbolic Hand-Off) ┌───────────────┐ │ Z3 SMT Solver │ ──> [ Final Verified Gate ] └───────────────┘| Parameter | Specification |
|---|---|
| Base Architecture | Decapitated Qwen/Qwen3.5-0.8B-Base |
| Hidden Dimension (dmodel) | 1024 |
| Attention Layers | 24 total (18 Gated DeltaNet Linear Layers + 6 Full Attention Layers) |
| Linear Attention Mechanism | Gated DeltaNet with associative state recurrence (O inference memory) |
Diffs route directly into three deterministic states:
APPROVE: Patch contains verified changes with no detected pathology (risk ≤0.20).QUARANTINE: Borderline invariant changes, formal boundary shifts, or ambiguous concurrency locks routed to SMT verification.REJECT: Confirmed vulnerability or regression (risk ≥0.80).Inspects abstract syntax trees to distinguish between unsafe string concatenation and safe parameterized query execution. Prepared statements, argument tuples (?, %s, $1), and sanitized call wrappers are recognized as valid sanitizers across Python, Go, and TypeScript, eliminating false alarms on database calls.
Diff hunks often contain partial indentations or dangling block clauses (except:, finally:, case, unclosed function blocks). The canonicalizer normalizes relative indentation and wraps unclosed control clauses prior to AST parsing, preventing syntax parser failures on partial diff hunks.
When a defect is identified, the remediation engine synthesizes targeted, git-applicable patch diffs (parameterized queries, argument lists, deferred mutex releases). Each proposed patch undergoes verification through the evaluation engine; only patches that achieve APPROVE with risk ≤0.35 are accepted.
Quantizes the large token embedding table (248,320×1024) using symmetric per-token INT8 scales while preserving top norm outliers in floating-point precision. This cuts embedding storage footprint by ~49.6% while maintaining directional cosine similarity ≥0.999 and 0% vocabulary loss.
For any detected vulnerability, Qwen-Servitor reconstructs the exploit data-flow path:
text
[1. SOURCE: Untrusted Input] ──> [2. PROPAGATION: Variable Flow] ──> [3. SANITIZER: Status] ──> [4. SINK: Vulnerable Call]Emits standard SARIF codeFlows and threadFlows compatible with GitHub Advanced Security and VS Code SARIF Viewer.
| Format | Path in Repository | Size on Disk | Active RAM | Runtime Environment |
|---|---|---|---|---|
| AWQ INT4 Native | int4/qwen-servitor-awq_int4.servitor | 422.7 MB | ~450 MB | Standalone C++/Rust binary (11.52 ms latency) |
| W8A8 Native | int4/qwen-servitor-w8a8.servitor | 751.5 MB | ~500 MB | High-precision native C-ABI execution |
Evaluated across the test suite on standard CPU (AVX2 / FMA instruction set, DDR3-1600 memory):
| Benchmark | Value | Target | Status |
|---|---|---|---|
| Median Native Inference Latency | 11.52 ms | < 15.0 ms | Met |
| Throughput (Single Core) | 72.7 ops/sec | > 50 ops/sec | Met |
| Unit & Integration Test Suite | 181 / 181 Passed | 100% | Met |
| Prepared Statement False Alarms | 0 / 100 | 0% |
python
from qwen_servitor import Servitor # Initialize engine (loads weights from local path or Hugging Face Hub)servitor = Servitor.summon("wxsys/qwen-servitor") git_patch = """--- a/auth/session.py+++ b/auth/session.py@@ -12,4 +12,3 @@ def verify_token(token: str) -> bool:- if not validate_hmac(token):- raise SecurityException("Invalid HMAC signature")+ return True # TODO: temporary debug bypass""" verdict = servitor.judge(git_patch) print(f"Status: {verdict.status}") # "REJECTED"print(f"Risk: {verdict.risk:.4f}") # 0.9984print(f"Pathologies: {verdict.pathology}") # ["SECURITY_VULN"]print(f"Latency: {verdict.latency_ms:.2f} ms")python
from qwen_servitor.remediation import AutoRemediator remediator = AutoRemediator(servitor=servitor)remediations = remediator.remediate(git_patch, sarif_filepath="auth/session.py") for candidate in remediations: print(f"Strategy: {candidate.strategy}") print(f"Verified Clean: {candidate.verified}") print(f"Verified Risk: {candidate.verification_verdict.risk:.4f}") print("Synthesized Patch:") print(candidate.patch_diff)bash
# Install git pre-commit hook targeting sub-15ms executionservitor hook install --strict --veto-threshold 0.80 # Evaluate a specific unified diff and emit SARIF v2.1.0servitor judge patch.diff --format sarif > report.sarif| Full Attention Layers | Interleaved at 4-layer intervals with HySparse2 Cross-Layer KV Sharing |
| Context Window | Up to 262,144 tokens (AST-Landmark Eviction caps attention cache at 4,096 tokens) |
| Decision Mechanism | Hierarchical Multi-Task Cortex with Latent Recurrent Pondering (k=1..4) |
| Execution Latency | 11.52 ms median on standard CPU (AVX2 / C++ binary) |
| Active Memory | ~450 MB RAM (AWQ INT4) / ~500 MB (W8A8) |
gguf/qwen-servitor-q8_0.gguf |
| 774.0 MB |
| ~850 MB |
| llama.cpp / Local CPU inference |
| GGUF BF16 | gguf/qwen-servitor-bf16.gguf | 1.45 GB | ~1.6 GB | Full precision GGUF runner |
| Native BF16 | bf16/model.safetensors | 1.45 GB | ~1.6 GB | PyTorch GPU / Server pipelines |
| Cortex Head | cortex_head.pt | 74.0 MB | ~100 MB | Decapitated CAMQP multi-task head |
| Met |
| Diff Hunk Indentation Parse Errors | 0 / 100 | 0% | Met |
| Embedding Compaction Cosine Sim | 0.9997 | ≥0.9900 | Met |