README.md

---
license: mit
base_model:
  - Qwen/Qwen3.5-4B
language:
  - en
tags:
  - pddl
  - planning
  - robotics
  - strips
  - neuro-symbolic
  - gguf
pipeline_tag: image-text-to-text
library_name: transformers
---

<p align="center">
  <img src="images/planium-logo.svg" alt="Planium" width="360">
</p>

# Planium-4B

**Planium-4B** is a 4B fine-tune of **Qwen3.5** specialized in **automated planning** and its
standard notation, **PDDL** (Planning Domain Definition Language). It is built primarily for
robotics and other control systems.

In its 4-bit quantized build, it is small enough to run on an ordinary PC or an embedded board such
as an NVIDIA Jetson — no cloud API, nothing leaves your machine.

## What it does

Classical planning in PDDL, largely limited to the `:strips` and `:strips :typing` fragments:

- turning a plain-language request into PDDL — typically the `:goal` or the problem file for a
  given domain,
- reading and explaining an existing domain, problem or plan,
- reasoning about states, preconditions, effects and goals,
- spotting what is wrong in a piece of PDDL,
- calling tools: it is trained to work in an agentic loop and to emit tool calls, so it can drive a
  parser, a planner or a plan validator itself instead of only producing text.

Temporal planning, numeric fluents and the richer ADL constructs are much less well supported.

The fine-tuning also mitigates a failure mode of the base Qwen3.5 on these tasks: reasoning that
never terminates, or that drags on far longer than the problem warrants without getting closer to an
answer. Planium-4B keeps its reasoning short and commits to an answer.

## Files

| File | Description |
| --- | --- |
| `model.safetensors-0000*-of-00002.safetensors` | Full weights (bfloat16) |
| `gguf/model.gguf` | Quantized build for llama.cpp (Q4_K_M, ~2.8 GB) |

## Usage

### llama.cpp

Download `gguf/model.gguf` and point `llama-cli` at it:

```bash
llama-cli -m /path/to/model.gguf
```

Or serve it over an OpenAI-compatible API:

```bash
llama-server -m /path/to/model.gguf --port 8080
```

### Transformers

```python
from transformers import AutoModelForImageTextToText, AutoTokenizer

model_id = "valentin0901/Planium-4B"
tok = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForImageTextToText.from_pretrained(model_id, dtype="bfloat16", device_map="auto")

messages = [{"role": "user", "content": "Write a STRIPS blocksworld domain."}]
inputs = tok.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt").to(model.device)
out = model.generate(inputs, max_new_tokens=1024)
print(tok.decode(out[0][inputs.shape[-1]:], skip_special_tokens=True))
```

## Built for NeuroPlan

Planium-4B is the model behind [**NeuroPlan**](https://github.com/valentin0901/NeuroPlan), a
neuro-symbolic planning system that bridges large language models and symbolic planners: it turns a
request into PDDL, hands it to the planner and runs the resulting plan.

| 3D Blocks World | Sokoban |
| --- | --- |
| ![Blocks World](images/blocks_world.PNG) | ![Sokoban](images/sokoban.PNG) |

| Drone patrol | PDDL chat |
| --- | --- |
| ![Patrol](images/patrol.PNG) | ![Chat PDDL](images/chat.PNG) |

## License

MIT — see [LICENSE](LICENSE).

## Status

Planium-4B is a **work in progress**. It can make mistakes.