license: mit
language:

• pt
• en
  base_model:
• tommytracx/Thox1-27b
• prism-ml/Bonsai-27B-gguf
  pipeline_tag: text-generation
  tags:
• code
• edge
• smart
• powerfuul
• best

VELUM UNBOUND

Local · Unbound · MTP

A 27-billion-parameter local AI model based on Thox1-27b, enhanced with Multi-Token Prediction.

Think. Write. Explore. Create.

Less restriction. More control.

About

Velum-Unbound-Uncensored is a 27-billion-parameter general-purpose language model built on top of tommytracx/Thox1-27b.

It is designed around a simple idea:

The user should control the model, not fight it.

Velum Unbound focuses on direct interaction, instruction following, reasoning, writing, roleplay, experimentation, and local AI use.

This version also incorporates Multi-Token Prediction (MTP), extending the traditional next-token prediction approach with additional future-token predictions.

The model follows the same philosophy as the rest of the Velum project:

local-first, practical, direct.

But unlike a task-specific model, Velum Unbound is designed as a general-purpose model.

Use it as an assistant.

Use it as a writer.

Use it for reasoning.

Use it for experiments.

Use it as the intelligence layer inside your own applications.

Your hardware. Your prompts. Your model.

Specifications

• Context capability depends on the base model, runtime, quantization, and inference configuration.

Unbound

Velum Unbound is designed to interfere as little as possible with the user's intent.

Instead of aggressively steering normal conversations toward predefined behaviors, the model aims to remain:

• direct;
• steerable;
• permissive;
• adaptable;
• neutral toward writing style;
• useful across unusual prompts;
• suitable for experimentation;
• responsive to custom system prompts.

The model can be shaped by the environment in which it runs.

SYSTEM PROMPT
      ↓
     USER
      ↓
VELUM UNBOUND
      ↓
   RESPONSE

The objective is not to decide what the user wants.

The objective is to follow the instruction well.

Unbound does not mean uncontrolled. It means user-directed.

Multi-Token Prediction

Traditional autoregressive language models predict the next token:

current state
     ↓
  token +1

Velum Unbound extends this approach with Multi-Token Prediction.

Conceptually:

              ┌── token +1
              │
hidden state ─┼── token +2
              │
              ├── token +3
              │
              └── token +N

Instead of learning only the immediate next token, MTP introduces prediction objectives for multiple future positions.

This provides additional training signals about where a sequence is going.

Why MTP?

Language is sequential.

Inference is sequential.

And sequential execution is expensive, because apparently generating one tiny integer at a time using billions of parameters was the plan.

MTP explores a different path.

Traditional

forward
   ↓
token
   ↓
forward
   ↓
token
   ↓
forward
   ↓
token

With MTP-aware inference:

forward
   ↓
multiple candidate tokens
   ↓
verification
   ↓
accepted sequence

When supported by the inference runtime, MTP predictions can potentially be used to propose several future tokens that are then verified by the main model.

The actual benefit depends on:

• MTP configuration;
• candidate acceptance rate;
• runtime implementation;
• quantization;
• hardware;
• context size;
• workload;
• verification strategy.

MTP does not automatically mean a fixed Nx speedup.

Measure it.

Benchmark it.

Then believe the number.

General Intelligence

Velum Unbound is not specialized around one task.

It is intended to remain useful across different workloads.

Reasoning

Analyze this problem carefully.

Identify:
- known information
- unknown information
- constraints
- possible approaches

Then derive the most reasonable answer.

Writing

Write a dark science-fiction short story about an abandoned
AI datacenter that continues operating decades after humanity disappeared.

Focus on atmosphere and environmental storytelling.

Analysis

Analyze the argument below.

Separate:
- factual claims
- assumptions
- opinions
- logical weaknesses
- strongest counterarguments

Then provide a neutral conclusion.

[TEXT]

Roleplay

You are the navigation computer of an interstellar research vessel.

Remain in character.

The ship has entered an unknown gravitational anomaly.

Begin with the first sensor warning.

Coding

Create a Python application that monitors system resources.

Requirements:
- CPU usage
- RAM usage
- disk usage
- terminal interface
- refresh every second
- clean shutdown

Return the complete implementation.

Agents

OBJECTIVE
Organize the provided project.

CONTEXT
You have access to the repository files.

TASK
Analyze the structure, identify problems, propose changes,
and produce an implementation plan before modifying anything.

Prompting

Velum Unbound works best when the objective is explicit.

A useful general structure is:

OBJECTIVE
What you want.

CONTEXT
Information the model needs.

REQUIREMENTS
What must happen.

CONSTRAINTS
What must not happen.

OUTPUT
How the answer should be returned.

Example:

OBJECTIVE
Design a local AI research assistant.

CONTEXT
The application runs completely offline and uses Python.

REQUIREMENTS
- document ingestion
- semantic search
- chat interface
- conversation history
- citations

CONSTRAINTS
- local execution
- no mandatory cloud APIs

OUTPUT
Return the architecture first, followed by the implementation plan.

Simple prompts are still perfectly valid.

Explain quantum entanglement without using mathematical notation.

or:

Write a story.

The structure exists when you need control.

Not because every conversation needs to look like a government procurement document.

Quantizations

Velum Unbound can be distributed in multiple GGUF quantization levels depending on the available builds.

The ideal choice depends mainly on:

RAM / VRAM → speed → fidelity

Q8 — Fidelity

For users with enough memory who want to preserve as much model fidelity as practical.

Q8_0

Q6 / Q5 — High Quality

Strong choices when memory is available but Q8 is unnecessarily large.

Q6_K · Q5_K_M · Q5_K_S

Q4 / IQ4 — Balanced

The recommended starting point for many systems.

Good balance between model size, memory requirements, and fidelity.

Q4_K_M · Q4_K_S · IQ4_XS · IQ4_NL

Q3 / IQ3 — Compact

For systems where memory is more limited.

Q3_K_L · Q3_K_M · Q3_K_S · IQ3_M · IQ3_S · IQ3_XS

Q2 / IQ2 — Ultra-Compact

Aggressive compression for hardware where larger versions do not fit.

Q2_K · Q2_K_S · IQ2_M · IQ2_S · IQ2_XS · IQ2_XXS

IQ1 — Extreme

Maximum compression.

IQ1_M

Expect a larger reduction in model fidelity.

Rule of thumb: start with Q4_K_M. Move upward for fidelity or downward when memory becomes the limiting factor.

Running Locally

llama.cpp

Download a compatible GGUF version.

llama-cli \
  -m ./Velum-Unbound-Uncensored-Q4_K_M.gguf \
  -p "Explain why the sky is blue."

For interactive conversation:

llama-cli \
  -m ./Velum-Unbound-Uncensored-Q4_K_M.gguf \
  -cnv

To expose a local server:

llama-server \
  -m ./Velum-Unbound-Uncensored-Q4_K_M.gguf \
  -c 32768

The model can then be connected to compatible local applications and OpenAI-style API clients supported by the runtime.

Ollama

Create a Modelfile:

FROM ./Velum-Unbound-Uncensored-Q4_K_M.gguf

PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER repeat_penalty 1.05

Then:

ollama create velum-unbound -f Modelfile
ollama run velum-unbound

Example:

>>> Explain how a transformer works from first principles.

LM Studio

1. Download a compatible GGUF quantization.
2. Import the model into LM Studio.
3. Load the model.
4. Configure the desired context size.
5. Start a conversation or local API server.

When running locally, inference does not require sending prompts to a remote AI provider.

MTP-Aware Inference

Standard GGUF runtimes may not automatically take advantage of the model's MTP components.

Traditional decoding can still operate through the primary autoregressive prediction path.

To obtain acceleration from MTP, the inference backend must explicitly support the MTP architecture and verification strategy used by the model.

Conceptually:

               VELUM
                 │
            transformer
                 │
           hidden state
                 │
       ┌─────────┼─────────┐
       ↓         ↓         ↓
     t + 1     t + 2     t + 3
       │         │         │
       └─────────┼─────────┘
                 ↓
             candidates
                 ↓
            verification
                 ↓
         accepted tokens

Compatibility depends on the runtime.

Do not assume that loading the model means MTP acceleration is active.

Recommended Generation

A reasonable starting point for general conversation:

temperature:    0.7
top_p:          0.9
repeat_penalty: 1.05

For more deterministic tasks:

temperature:    0.2 - 0.5
top_p:          0.9

For creative generation:

temperature:    0.8 - 1.0
top_p:          0.95

These are starting points, not sacred constants.

Experiment.

Benchmarks

Benchmarks should describe the actual distributed checkpoint.

Not the model we wish existed.

For MTP builds, inference benchmarks should ideally include:

MODEL
HARDWARE
QUANTIZATION
CONTEXT
BACKEND
MTP HEADS
ACCEPTANCE RATE
TOKENS / SECOND

Without the environment, a tokens-per-second number means very little.

Hardware

Resource usage depends on:

• quantization;
• context length;
• KV cache;
• CPU;
• GPU;
• memory bandwidth;
• number of GPU-offloaded layers;
• inference backend;
• MTP implementation.

In general:

higher precision
      ↑
more fidelity
      ↑
more memory


more compression
      ↓
less memory
      ↓
potential fidelity loss

A 27B model remains a 27B model.

Quantization can make it surprisingly small.

It cannot repeal physics.

Limitations

Velum Unbound is still a language model.

It may:

• hallucinate facts;
• generate incorrect information;
• make reasoning errors;
• misunderstand ambiguous instructions;
• produce incorrect code;
• invent APIs, references, or sources;
• contradict itself;
• confidently provide a wrong answer.

MTP does not magically solve hallucinations.

Quantization may also affect model behavior and output quality, particularly at aggressive compression levels.

For factual, technical, financial, medical, legal, security-sensitive, or otherwise important tasks, verify the output independently.

Confidence is not evidence.

Responsible Use

Velum Unbound is designed to provide the user with a high degree of control.

That control also means responsibility remains with the person operating the model.

Review outputs before using them in consequential environments.

Validate generated code before execution.

Do not expose credentials unnecessarily.

Use isolated environments when experimenting with unknown generated code.

Respect applicable laws, licenses, privacy requirements, and the rights of others.

Capability and responsibility belong together.

Base Model

Velum-Unbound-Uncensored is based on:

tommytracx/Thox1-27b

which is itself derived from the Qwen 3.5 model family.

The base model provides the underlying language, reasoning, and general-generation capabilities upon which Velum Unbound is built.

Review the model cards and licenses of all upstream components before redistribution or commercial deployment.

Philosophy

PROMPT
   ↓
INTENT
   ↓
VELUM UNBOUND
   ↓
REASON
   ↓
GENERATE
   ↓
USER CONTROL

No cloud requirement.

No mandatory external service.

No artificial complexity.

Your machine runs the model.

Your prompt defines the task.

The model does the work.

License

Use of Velum-Unbound-Uncensored is subject to the license published with this repository and the licensing requirements inherited from its upstream models.

Review the repository LICENSE and all applicable upstream licenses before commercial use, redistribution, or creation of derivatives.

Brazil

🇧🇷 MADE IN BRAZIL

Intelligence that stays close.

Local-first · Unbound · MTP

THINK · CREATE · EXPLORE · BUILD

VELUM © 2026