👉 Visit the Velum AI Landing Page 👉 see the power of this model
A local model based on Qwen 3.5 9B, focused on software development.
Write. Understand. Fix. Refactor. Build.
Less ceremony. More working code. Note: LEVUM is a code-focused model optimized for agentic platforms and code editors, not for standard chat or general conversation.
LEVUM is a 9-billion-parameter model, based on Qwen 3.5 9B and focused on software development tasks.
The goal is simple: work close to the project and turn instructions into useful code.
The model was designed for tasks such as:
LEVUM follows a local-first philosophy: the model can run close to the IDE, files, and the actual project context, depending on the chosen runtime and quantization.
Software first. Local by default.
| Model | LEVUM |
| Base | Qwen 3.5 9B |
| Parameters | 9B |
| Focus | Code / Software |
| Primary use | Software development |
| Execution | Local |
| Language | English + multilingual capabilities of the base model |
| Origin | 🇧🇷 Brazil |
LEVUM is available in different quantization levels to support a wider range of hardware.
The ideal choice mainly depends on:
RAM / VRAM → speed → fidelity
Comparison of the model's relative quality after different quantization levels:
Defined values: Q8 = 99%, Q4 = 50%, Q3 = 30%, Q2 = 25%, and Q1 = 10%.
For machines with enough memory and users who want to preserve as much of the model's quality as possible.
Q8_0
The recommended sweet spot for many local systems.
A good balance between size, memory usage, and quality.
Q4_K_M · Q4_K_S · IQ4_XS · IQ4_NL · Q4_1 · Q4_0
For more limited hardware or situations where reducing RAM/VRAM usage is a priority.
Q3_K_L · Q3_K_M · Q3_K_S · IQ3_M · IQ3_S · IQ3_XS · IQ3_XXS
Aggressive compression for environments where larger versions simply do not fit.
Q2_K · Q2_K_S · IQ2_M · IQ2_S · IQ2_XS · IQ2_XXS · Q2_0 · TQ2_0
The extreme option.
IQ1_M
Recommended only when saving memory is more important than preserving maximum model fidelity.
Rule of thumb: start with
Q4_K_M. If you have memory to spare, tryQ8_0. If memory is limited, move down to Q3, Q2, or IQ1.
Download one of the GGUF versions of LEVUM and run it with a GGUF-compatible runtime.
llama-cli \
-m ./LEVUM-Q4_K_M.gguf \
-p "Create a REST API in Python using FastAPI."
To start a local server:
llama-server \
-m ./LEVUM-Q4_K_M.gguf \
-c 8192
After that, the model can be integrated with local tools that support compatible endpoints.
Create a Modelfile pointing to the GGUF:
FROM ./LEVUM-Q4_K_M.gguf
PARAMETER temperature 0.6
PARAMETER top_p 0.9
Then:
ollama create levum -f Modelfile
ollama run levum
Example:
>>> Create a FastAPI API for managing projects and tasks.
No remote infrastructure is required for inference when the model is running locally.
LEVUM works best when the task, context, and expected output format are explicit.
Create an interactive financial dashboard in a single HTML file.
Requirements:
- HTML, CSS, and JavaScript in the same file
- interactive charts
- responsive
- sample data
- no mandatory external dependencies
Return only the complete HTML.
Analyze the code below and implement JWT authentication.
Requirements:
- preserve the current architecture
- validate expired tokens
- add authentication middleware
- do not modify public endpoints
- explain only important decisions
Code:
[paste the code here]
Find the cause of the bug in the code below.
Expected behavior:
[describe]
Current behavior:
[describe]
Error:
[paste the error]
Code:
[paste the code]
Identify the cause and return the complete fix.
Refactor this code.
Goals:
- reduce duplication
- improve readability
- preserve current behavior
- preserve the public API
- avoid unnecessary abstractions
Return the refactored code first, followed by a short summary of the changes.
Use this system prompt (it makes the model decrease hallucinations).
Before writing any code, plan out ALL the variables and functions, as well as the complete logic (code design) to be used.
In the reasoning phase, first define:
* how the code will work (e.g., first I will declare the variables, then write function 1, then function 2...);
* all variables;
* all functions;
* parameters;
* return values;
* types;
* scopes.
Create an internal, fixed list of variables and functions before generating the code.
During generation:
* use only the variables and functions that have already been planned;
* do not invent new names mid-code;
* do not rename symbols;
* do not use a variable before defining it;
* if you realize a new symbol is needed, stop, update the internal plan first, and only then continue;
* maintain valid syntax for the language.
For larger tasks, a simple structure usually produces more predictable results:
OBJECTIVE
What needs to be built.
CONTEXT
Stack, existing files, and architecture.
REQUIREMENTS
Mandatory behaviors.
CONSTRAINTS
What must not be changed.
OUTPUT
Exact expected format.
For example:
OBJECTIVE
Create an analytics page.
CONTEXT
React + TypeScript + Tailwind project.
REQUIREMENTS
- revenue chart
- period filters
- metric cards
- transactions table
CONSTRAINTS
- do not add new dependencies
- reuse existing components
OUTPUT
Return the complete files that need to be created or modified.
LEVUM was designed to work within the normal development cycle:
PROMPT / CODE
↓
LEVUM
↓
UNDERSTAND
↓
GENERATE
↓
DEBUG
↓
REFACTOR
↓
RUNNING SOFTWARE
Projects, components, APIs, scripts, and features.
Analysis of errors, unexpected behavior, and fixes.
Structure, readability, and maintenance of existing code.
Turn an idea into something executable quickly.
Prompt
Create a Flappy Bird-style game in a single HTML file.
Use only HTML, CSS, and JavaScript.
Include:
- physics
- obstacles
- collision detection
- scoring
- restart
- keyboard and click controls
Return only the complete HTML.
Expected result
prompt
↓
LEVUM
↓
HTML + CSS + JavaScript
↓
browser
↓
running software
Actual resource usage depends on several factors, including:
Because of this, memory requirements can vary significantly between systems.
As a general rule:
more bits
↑
more fidelity
↑
more memory
fewer bits
↓
less memory
↓
more compression
Choose the quantization based on the available hardware and the quality required for the task.
LEVUM is still a language model.
This means it may:
For important software, review, test, and validate the code before putting it into production.
AI-generated code does not gain magical powers just because it compiled once.
Before running code generated by the model:
For critical applications, the model should serve as an assistance tool, not as the only layer of review.
LEVUM is based on:
Qwen 3.5 9B
The base model provides the general capabilities upon which LEVUM is built.
Also review the base model's model card and license before distributing or using derivatives.
Use of LEVUM is subject to the license published in this repository and, where applicable, the terms and conditions associated with the base model.
Review the LICENSE file before commercial use, redistribution, or creating derivatives.
Intelligence that stays close.
Local-first · Code-first · Software-first
BUILD · DEBUG · REFACTOR · SHIP
LEVUM © 2026
Have the files? Submit a torrent.
Submit a torrentHave the complete files and permission to share them? Replace the example folder path. The script checks the files, makes a torrent and submits its magnet and checksums. Keep your torrent client seeding. Get your community key from your settings, and read the script before running it.
curl -fsSL https://pirateface.co/package.sh | bash -s -- --repo guell00/VELUM-Coder ./model-folderornith-ai/Ornith-1.5-9B