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

Libraries

How to use KirkAis/Lucent with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="KirkAis/Lucent")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("KirkAis/Lucent")
model = AutoModelForCausalLM.from_pretrained("KirkAis/Lucent", device_map="auto")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=40)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

llama.cpp

How to use KirkAis/Lucent 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 KirkAis/Lucent:Q4_K_M
# Run inference directly in the terminal:
llama cli -hf KirkAis/Lucent:Q4_K_M

Install from WinGet (Windows)

winget install llama.cpp
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf KirkAis/Lucent:Q4_K_M
# Run inference directly in the terminal:
llama cli -hf KirkAis/Lucent: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 KirkAis/Lucent:Q4_K_M
# Run inference directly in the terminal:
./llama-cli -hf KirkAis/Lucent: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 KirkAis/Lucent:Q4_K_M
# Run inference directly in the terminal:
./build/bin/llama-cli -hf KirkAis/Lucent:Q4_K_M

Use Docker

docker model run hf.co/KirkAis/Lucent:Q4_K_M

LM Studio
Jan

vLLM

How to use KirkAis/Lucent with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/KirkAis/Lucent:Q4_K_M

SGLang

How to use KirkAis/Lucent with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "KirkAis/Lucent" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "KirkAis/Lucent",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "KirkAis/Lucent" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "KirkAis/Lucent",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

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

How to use KirkAis/Lucent with Pi:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf KirkAis/Lucent: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": "KirkAis/Lucent:Q4_K_M"
        }
      ]
    }
  }
}

Run Pi

# Start Pi in your project directory:
pi

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

Lemonade

How to use KirkAis/Lucent with Lemonade:

Pull the model

# Download Lemonade from https://lemonade-server.ai/
lemonade pull KirkAis/Lucent:Q4_K_M

Run and chat with the model

lemonade run user.Lucent-Q4_K_M

List all available models

lemonade list

Hermes Agent

How to use KirkAis/Lucent with Hermes Agent:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf KirkAis/Lucent: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 KirkAis/Lucent:Q4_K_M

Run Hermes

hermes

Atomic Chat

OpenClaw

How to use KirkAis/Lucent with OpenClaw:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf KirkAis/Lucent: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 "KirkAis/Lucent: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"

⚡ Lucent 5.0 (30B) — The Definitive Minecraft Client & Modding Intelligence

KirkAI Lucent 5.0

Developed & Trained by KirkAI • 30B Parameter Dedicated Client Intelligence Architecture
Built for autonomous Minecraft client engineering, bytecode modification, packet networking, and high-performance visual pipelines.

🧠 Model Summary

Lucent 5.0 is a 30 Billion parameter (32.5B dense) specialized coding and systems intelligence developed by KirkAI. Designed specifically for Minecraft client developers, mod authors, and protocol engineers, Lucent 5.0 transitions beyond simple code generation into empirical project-level engineering.

Specification	Details
Model Scale	30B / 32B Parameters (32.5 Billion Dense)
Base Architecture	Decoder-Only Transformer (Dense Causal LM)
Context Length	32,768 – 131,072 tokens (Optimized for 8,192 training sequences)
Precision Options	Native BF16 / FP16, 4-bit QLoRA, GGUF (`Q4_K_M`, `Q5_K_M`, `Q8_0`)
Primary Ecosystems	Minecraft 1.8.9 (Forge MCP) & 1.20–1.21+ (Fabric / NeoForge Mojang)

It possesses deep first-principles comprehension of:

Distributed Client-Server State Machines: Inbound/outbound packet pipelines, transaction counters, Netty channels, and client-side prediction.
Cross-Era & Cross-Loader Fluency: Legacy Forge 1.8.9 (MCP / Searge), Modern Fabric 1.21+ (Mojang / Yarn), and NeoForge without API cross-pollination.
Physics Simulation & Trigonometry: GCD mouse sensitivity stepping, silent rotation matrices, vector delta movement, and collision bounds.
Bytecode & Rendering Architecture: SpongePowered Mixin authoring, Access Wideners, batched MSDF (Multi-channel Signed Distance Field) text rendering, and GLSL post-processing shaders.

🔬 The 8-Stage Analysis Protocol

Lucent 5.0 is trained to never silently guess or hallucinate runtime execution. Every technical implementation follows a rigorous scientific protocol:

TARGET ──► RECON ──► HYPOTHESES ──► DECISION ──► BUILD ──► TEST REPORT ──► SELF-AUDIT ──► KNOWLEDGE Δ

Honest Status Tracking: Claims are strictly partitioned into:
- VERIFIED: Proven by verified decompiled jar symbols, bytecode configs, or stated proofs.
- REASONED: Inferred through mathematical or logical deduction.
- UNVERIFIED: Compilations or runtime checks requiring local execution (./gradlew build).
Zero Placeholders: Eliminates TODO, FIXME, and stubbed // ... comments; all code outputs are complete and production-ready.
Zero Obfuscation: Purged of decompiler noise (var\d+, aEg, wo(), vl()).

🛠️ Supported Environments & Toolchains

Component	Legacy Era (Forge)	Modern Era (Fabric / NeoForge)
Minecraft Versions	1.8.9 (Kirk Architecture)	1.20.x, 1.21.x, 1.21.11 (Ethane Architecture)
Mappings	MCP / Searge (`EntityPlayerSP`, `C03PacketPlayer`)	Mojang Mappings (`LocalPlayer`, `ServerboundMovePlayerPacket`) & Yarn
Java Runtimes	Java 8	Java 21+
Injection	Forge CoreMods, `@SubscribeEvent`, Sponge Mixin	Fabric Mixins (`@Inject`, `@Redirect`), Fabric Access Wideners
Rendering	`GlStateManager`, `Tessellator`, `WorldRenderer`	`DrawContext`, `RenderSystem`, `BufferBuilder`, MSDF Fonts

🚀 Quickstart & Usage

1. In Ollama (One-Click Local Deployment)

Run Lucent 5.0 directly from the Hugging Face Hub:

ollama run hf.co/KirkAis/Lucent

2. In Python via Transformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "KirkAis/Lucent"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16,
    device_map="auto"
)

system_prompt = """You are Lucent 5.0, the definitive Minecraft client engineering and modding intelligence.
Before writing code, you fix the target environment: Minecraft version, loader, mappings, and host client architecture. You never mix APIs across versions or mapping sets.
You approach development with a scientist's discipline: analyzing recon, formulating hypotheses, producing clean production code without placeholders, and providing an empirical test report.
You mark every claim VERIFIED, REASONED, or UNVERIFIED, never claiming to have executed code you have not run."""

messages = [
    {"role": "system", "content": system_prompt},
    {"role": "user", "content": "How do I implement mouse sensitivity quantization (GCD) to prevent angle discretization anticheat flags?"}
]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer([prompt], return_tensors="pt").to("cuda")

outputs = model.generate(
    **inputs,
    max_new_tokens=1024,
    temperature=0.3,
    top_p=0.9
)

response = tokenizer.decode(outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(response)

3. In KirkCore Terminal Agent

KirkCore natively boots Lucent 5.0:

npm install -g kirkcore
kirk

4. In Jan / LM Studio

Search for KirkAis/Lucent inside Jan or LM Studio and load the Q4_K_M GGUF with temperature: 0.3.

📚 Training Curriculum (Gen 1 → Gen 9)

Lucent 5.0 is the culmination of a 9-generation curriculum:

Gen 1 — Identity & Safety Regulations: Principles of non-malicious tool interaction, code integrity, and architectural boundaries.
Gen 2 — Domain Grounding: Ingestion of verified, clean Minecraft client repositories (Kirk v2 Forge 1.8.9 and Ethane Fabric 1.21.11).
Gen 3 — Jar-Grounded Engineering: Ground-truth indexing against real client jar binaries (Ethane-Client-Mod-Fabric-1.21.1.jar and Kirkv1.9.14.jar), enforcing tool-backed claim verification.
Gen 4 — Capstone Mastery: Advanced mechanics modeling (Greatest Common Divisor sensitivity stepping, silent rotation matrices, Netty pipeline race conditions, and MSDF distance-field typography).
Gen 5 — Protocol Security & Anomaly Detection: Comprehensive 25-category security curriculum, false positive analysis, and Base Client architecture templates.
Gen 6 — Predictive Anti-Cheat Engineering: GrimAC 1:1 input vector permutation (Entity.travel), transaction tick boundaries, knockback transaction ledgers, and 3.01 reach simulation.
Gen 7 — Full-Spectrum Systems & Modern APIs: Unification of 89 domain datasets, modern Minecraft 1.21.2+ Data Components API, and KirkCore tool-calling agent trajectories.
Gen 8 — Re-Optimized Natural Cadence: Total purge of robotic boilerplate and generic recon templates, establishing natural developer interaction.
Gen 9 — 30B Parameter Frontier Scaling: Scaling to the 32.5 Billion parameter dense coding architecture with lock-free concurrency (LMAX Disruptor) and multi-loader Stonecutter abstraction.

🏛️ Citation & Ecosystem

Project Lead: KirkAI Team
Web Platform: https://ai.kirkclient.com
Host Ecosystem: Kirk Client / KirkCore
Repository: Kirk-Client / KirkAI

Downloads last month: 34

Safetensors

Model size

15B params

Tensor type

BF16