Instructions to use JuanCDEV/rovalthia with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Notebooks
Google Colab
Kaggle
Local Apps Settings

How to use JuanCDEV/rovalthia with llama.cpp:

Install (macOS, Linux)

curl -LsSf https://llama.app/install.sh | sh
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf JuanCDEV/rovalthia:Q4_K_M
# Run inference directly in the terminal:
llama cli -hf JuanCDEV/rovalthia:Q4_K_M

Install from WinGet (Windows)

winget install llama.cpp
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf JuanCDEV/rovalthia:Q4_K_M
# Run inference directly in the terminal:
llama cli -hf JuanCDEV/rovalthia:Q4_K_M

Use pre-built binary

# Download pre-built binary from:
# https://github.com/ggerganov/llama.cpp/releases
# Start a local OpenAI-compatible server with a web UI:
./llama-server -hf JuanCDEV/rovalthia:Q4_K_M
# Run inference directly in the terminal:
./llama-cli -hf JuanCDEV/rovalthia:Q4_K_M

Build from source code

git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
cmake -B build
cmake --build build -j --target llama-server llama-cli
# Start a local OpenAI-compatible server with a web UI:
./build/bin/llama-server -hf JuanCDEV/rovalthia:Q4_K_M
# Run inference directly in the terminal:
./build/bin/llama-cli -hf JuanCDEV/rovalthia:Q4_K_M

Use Docker

docker model run hf.co/JuanCDEV/rovalthia:Q4_K_M

LM Studio
Jan

vLLM

How to use JuanCDEV/rovalthia with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "JuanCDEV/rovalthia"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "JuanCDEV/rovalthia",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/JuanCDEV/rovalthia:Q4_K_M

Ollama
How to use JuanCDEV/rovalthia with Ollama:
```
ollama run hf.co/JuanCDEV/rovalthia:Q4_K_M
```
Unsloth Desktop

How to use JuanCDEV/rovalthia with Pi:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf JuanCDEV/rovalthia:Q4_K_M

Configure the model in Pi

# Install Pi:
npm install -g @earendil-works/pi-coding-agent
# Add to ~/.pi/agent/models.json:
{
  "providers": {
    "llama-cpp": {
      "baseUrl": "http://localhost:8080/v1",
      "api": "openai-completions",
      "apiKey": "none",
      "models": [
        {
          "id": "JuanCDEV/rovalthia:Q4_K_M"
        }
      ]
    }
  }
}

Run Pi

# Start Pi in your project directory:
pi

Docker Model Runner
How to use JuanCDEV/rovalthia with Docker Model Runner:
```
docker model run hf.co/JuanCDEV/rovalthia:Q4_K_M
```

Lemonade

How to use JuanCDEV/rovalthia with Lemonade:

Pull the model

# Download Lemonade from https://lemonade-server.ai/
lemonade pull JuanCDEV/rovalthia:Q4_K_M

Run and chat with the model

lemonade run user.rovalthia-Q4_K_M

List all available models

lemonade list

Hermes Agent

How to use JuanCDEV/rovalthia with Hermes Agent:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf JuanCDEV/rovalthia:Q4_K_M

Configure Hermes

# Install Hermes:
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
hermes setup
# Point Hermes at the local server:
hermes config set model.provider custom
hermes config set model.base_url http://127.0.0.1:8080/v1
hermes config set model.default JuanCDEV/rovalthia:Q4_K_M

Run Hermes

hermes

Atomic Chat

OpenClaw

How to use JuanCDEV/rovalthia with OpenClaw:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf JuanCDEV/rovalthia:Q4_K_M

Configure OpenClaw

# Install OpenClaw:
npm install -g openclaw@latest
# Register the local server and set it as the default model:
openclaw onboard --non-interactive --mode local \
  --auth-choice custom-api-key \
  --custom-base-url http://127.0.0.1:8080/v1 \
  --custom-model-id "JuanCDEV/rovalthia:Q4_K_M" \
  --custom-provider-id llama-cpp \
  --custom-compatibility openai \
  --custom-text-input \
  --accept-risk \
  --skip-health

Run OpenClaw

openclaw agent --local --agent main --message "Hello from Hugging Face"

ROLLY-AGENTIC-CYBER-12-9T

Organization: ROVALTHIA LABORATORY
Official Repository: JuanCDEV/rovalthia
Curated Dataset Repository: JuanCDEV/rovalthia-data
Product Version: 12-9T (Release Candidate: v1.0.0-rc1)
Base Lineage: Qwen3.5 Architecture & Physical Safetensors Checkpoints
License: Apache 2.0

1. Product Identity vs. Physical Parameter Count

Product Naming & Scientific Truthfulness Declaration:

Product Identity: ROLLY-AGENTIC-CYBER-12-9T (Branding: ROLLY by ROVALTHIA).

Physical Parameter Count: $4,659,865,088$ ($4.66\text{B}$ parameters, verified across 738 physical safetensors tensors).

Target Architecture Class: $11,488,739,328$ ($11.49\text{B}$ parameters, ROLLY-12B-A dense architecture). Full 12B physical weight materialization is pending multi-GPU cluster allocation.

Pre-training Budget Target: $9,000,000,000,000$ ($9\text{T}$) curriculum data budget specification.

Actual Trained Tokens: $0$ on local hardware.

Release Classification: RELEASE_CLASS = ROLLY_RC_BASELINE.

2. Model Architecture & Forensic Tensor Verification

Full tensor-level audit derived from physical Safetensors headers via tools/verify_parameter_count.py:

Property	Measured Value	Verification Method
Physical Parameter Count	$4,659,865,088$	Binary Safetensors Header Count (738 tensors)
Total Weight Bytes	$9,319,737,856$ bytes ($8.68\text{ GiB}$)	Physical filesystem verification
Weight Shards	2 shards (`model.safetensors-00001/00002`)	Index integrity checked
Canonical GGUF	`ROLLY-AGENTIC-CYBER-12-9T.GGUF` (2.78 GB)	Q4_K_M quantization verified
SHA-256 (Shard 1)	`26a93f066e1916adb13453dae5a0c707c0fbc71299ed98779571a907b8e74c61`	Forensic SHA-256
SHA-256 (Shard 2)	`cb544bd9bfae93dc59b0f22b292f5933573854a7f9b97835c67060d7d910e188`	Forensic SHA-256
SHA-256 (Canonical GGUF)	`224D35AAC064EC20B936B2D8DE4124F462D96E00A2FE212F549556E02919089B`	Forensic SHA-256
Configured Context Window	$1,048,576$ tokens ($1\text{M}$)	YaRN RoPE factor 8.0 ($\beta_{\text{fast}}=32, \beta_{\text{slow}}=1$)

3. Training Status & Curriculum (D1–D17)

The training curriculum is structured into 17 specialized domains:

D1 Instruction $\to$ D2 Mathematics $\to$ D3 Reasoning $\to$ D4 Coding $\to$ D5 Structured Output $\to$ D6 Tool Use $\to$ D7 Agent Routing $\to$ D8 Documents $\to$ D9 Multilingual $\to$ D10 Defensive Cyber $\to$ D11 Formal Math $\to$ D12 Long Context $\to$ D13 Software Engineering $\to$ D14 Research $\to$ D15 Memory $\to$ D16 Agent Planning $\to$ D17 Scientific Reasoning.

Pipeline Workflow: TRAIN -> VALIDATE -> BENCHMARK -> REGRESSION -> ACCEPT/REJECT.
Current Status: STAGED_READY_FOR_GPU_CLUSTER. Host system (4 GB available RAM, CPU-only) gates full physical 12B training until enterprise GPU nodes (H100/A100) are attached.

4. Subsystems Architecture

A. Memory Mesh V3

Operates across 10 strictly isolated scopes: WORKING, CONVERSATION, EPISODIC, SEMANTIC, PROCEDURAL, SKILL, TOOL, AGENT, DOCUMENT, RETRIEVAL. Features multi-tenancy isolation and the MemoryCurator for automatic TTL expiration and deduplication.

B. Skill System V2 & Economy Routing

Includes 17 skill families and 18 core verified skills governed by the EconomyRoutingSkill:

Policy: MINIMUM_NECESSARY_COMPUTE — Enforces minimal agent hops (default: 1 active agent).
Tiers: TINY (direct response), SIMPLE (local ROLLY), NORMAL (ROLLY + 1 specialist), COMPLEX (Planner + specialists), EXPERT (Deep reasoning + verifier).
Internal Optimization Telemetry: Achieved ~50% token reduction in internal multi-turn context compression benchmarks with zero external API calls (LOCAL_FIRST=YES).

C. Knowledge Factory & RAG

10 research papers on Zero Trust, CTI threat hunting, and Agentic security ingested into 418 verified RAG chunks with page citations.
Model weights are strictly immutable during document ingestion (weights_mutated = False).

5. Benchmark Performance & Targets

In compliance with ROVALTHIA Scientific Integrity rules, benchmark numbers are rigorously categorized:

Benchmark Suite	Status / Category	Score / Value	Harness & Mode
General Knowledge	`INTERNAL_MEASURED`	100.0%	Local Harness (Model-Only, Ext Provider OFF)
Instruction Following	`INTERNAL_MEASURED`	100.0%	Local IFEval Diagnostic Split
Defensive Cyber	`INTERNAL_MEASURED`	100.0%	CTI Threat Modeling Diagnostic
Document Intelligence	`INTERNAL_PROXY`	95.0%	Knowledge Factory Grounding Proxy
Reasoning	`INTERNAL_PROXY`	70.0%	Deductive Logic Proxy (GPQA Target: 95.2)
Coding	`INTERNAL_PROXY`	62.0%	SWE / Python Unit Test Proxy
Agentic Execution	`INTERNAL_PROXY`	60.0%	CoWork Diagnostic Proxy
Terminal Bench 2.1	`ASPIRATIONAL_TARGET`	89.9 Target	Pending Official Sandboxed Cluster
SWE-bench Pro	`ASPIRATIONAL_TARGET`	82.4 Target	Pending Official Sandboxed Cluster
DeepSWE 1.1	`ASPIRATIONAL_TARGET`	74.8 Target	Pending Official Sandboxed Cluster
GPQA Diamond	`ASPIRATIONAL_TARGET`	95.2 Target	Pending Official Sandboxed Cluster
HLE	`ASPIRATIONAL_TARGET`	55.0 Target	Pending Official Sandboxed Cluster
IFBench	`ASPIRATIONAL_TARGET`	84.5 Target	Pending Official Sandboxed Cluster
LongBench v2	`ASPIRATIONAL_TARGET`	71.8 Target	Pending Official Sandboxed Cluster

Aspirational targets reflect technical qualification goals, not measured results. No claim of superior performance over competitor systems is asserted without comparable certified evaluation.

6. How to Run

llama.cpp (Tested & Verified)

./llama-cli \
  -m ROLLY-AGENTIC-CYBER-12-9T.GGUF \
  -p "<|im_start|>system\nYou are ROLLY-AGENTIC-CYBER-12-9T, an autonomous defensive cybersecurity agent.<|im_end|>\n<|im_start|>user\nExplain Identity-Aware Reverse Proxy architectures.<|im_end|>\n<|im_start|>assistant\n" \
  -c 32768 \
  --temp 0.3 \
  -n 2048

Python / Transformers

from transformers import AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("JuanCDEV/rovalthia")
model = AutoModelForCausalLM.from_pretrained("JuanCDEV/rovalthia", torch_dtype="auto", device_map="auto")

inputs = tokenizer("Explain Zero Trust perimeter defense in cloud environments.", return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=256, temperature=0.3)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

7. Citation

@misc{rovalthia2026rolly,
  author = {ROVALTHIA LABORATORY and JuanCDEV},
  title = {ROLLY-AGENTIC-CYBER-12-9T: Autonomous Agentic Intelligence and Defensive Cybersecurity Foundation},
  year = {2026},
  publisher = {Hugging Face},
  howpublished = {\url{https://huggingface.co/JuanCDEV/rovalthia}}
}

Downloads last month: 261

Safetensors

Model size

5B params

Tensor type

BF16

F32

Model tree for JuanCDEV/rovalthia

Base model

Qwen/Qwen2.5-7B

Finetuned

Qwen/Qwen2.5-Coder-7B

Finetuned

Qwen/Qwen2.5-Coder-7B-Instruct

Quantized

(248)

this model