Instructions to use htunn/thousands-eye-gguf with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use htunn/thousands-eye-gguf with Transformers:

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

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

# Load model directly
from transformers import AutoModel
model = AutoModel.from_pretrained("htunn/thousands-eye-gguf", device_map="auto")

MLX

How to use htunn/thousands-eye-gguf with MLX:

# Make sure mlx-lm is installed
# pip install --upgrade mlx-lm

# Generate text with mlx-lm
from mlx_lm import load, generate

model, tokenizer = load("htunn/thousands-eye-gguf")

prompt = "Write a story about Einstein"
messages = [{"role": "user", "content": prompt}]
prompt = tokenizer.apply_chat_template(
    messages, add_generation_prompt=True
)

text = generate(model, tokenizer, prompt=prompt, verbose=True)

Notebooks
Google Colab
Kaggle
Local Apps Settings

llama.cpp

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

Install from WinGet (Windows)

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

Use Docker

docker model run hf.co/htunn/thousands-eye-gguf:Q4_K_M

LM Studio
Jan

vLLM

How to use htunn/thousands-eye-gguf with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/htunn/thousands-eye-gguf:Q4_K_M

SGLang

How to use htunn/thousands-eye-gguf 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 "htunn/thousands-eye-gguf" \
    --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": "htunn/thousands-eye-gguf",
		"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 "htunn/thousands-eye-gguf" \
        --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": "htunn/thousands-eye-gguf",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Ollama
How to use htunn/thousands-eye-gguf with Ollama:
```
ollama run hf.co/htunn/thousands-eye-gguf:Q4_K_M
```

Unsloth Studio

How to use htunn/thousands-eye-gguf with Unsloth Studio:

Install Unsloth Studio (macOS, Linux, WSL)

curl -fsSL https://unsloth.ai/install.sh | sh
# Run unsloth studio
unsloth studio -H 0.0.0.0 -p 8888
# Then open http://localhost:8888 in your browser
# Search for htunn/thousands-eye-gguf to start chatting

Install Unsloth Studio (Windows)

irm https://unsloth.ai/install.ps1 | iex
# Run unsloth studio
unsloth studio -H 0.0.0.0 -p 8888
# Then open http://localhost:8888 in your browser
# Search for htunn/thousands-eye-gguf to start chatting

Using HuggingFace Spaces for Unsloth

# No setup required
# Open https://huggingface.co/spaces/unsloth/studio in your browser
# Search for htunn/thousands-eye-gguf to start chatting

How to use htunn/thousands-eye-gguf with Pi:

Start the MLX server

# Install MLX LM:
uv tool install mlx-lm
# Start a local OpenAI-compatible server:
mlx_lm.server --model "htunn/thousands-eye-gguf"

Configure the model in Pi

# Install Pi:
npm install -g @mariozechner/pi-coding-agent
# Add to ~/.pi/agent/models.json:
{
  "providers": {
    "mlx-lm": {
      "baseUrl": "http://localhost:8080/v1",
      "api": "openai-completions",
      "apiKey": "none",
      "models": [
        {
          "id": "htunn/thousands-eye-gguf"
        }
      ]
    }
  }
}

Run Pi

# Start Pi in your project directory:
pi

Hermes Agent new

How to use htunn/thousands-eye-gguf with Hermes Agent:

Start the MLX server

# Install MLX LM:
uv tool install mlx-lm
# Start a local OpenAI-compatible server:
mlx_lm.server --model "htunn/thousands-eye-gguf"

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 htunn/thousands-eye-gguf

Run Hermes

hermes

Atomic Chat new

OpenClaw new

How to use htunn/thousands-eye-gguf with OpenClaw:

Start the MLX server

# Install MLX LM:
uv tool install mlx-lm
# Start a local OpenAI-compatible server:
mlx_lm.server --model "htunn/thousands-eye-gguf"

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 "htunn/thousands-eye-gguf" \
  --custom-provider-id mlx-lm \
  --custom-compatibility openai \
  --custom-text-input \
  --accept-risk \
  --skip-health

Run OpenClaw

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

MLX LM

How to use htunn/thousands-eye-gguf with MLX LM:

Generate or start a chat session

# Install MLX LM
uv tool install mlx-lm
# Interactive chat REPL
mlx_lm.chat --model "htunn/thousands-eye-gguf"

Run an OpenAI-compatible server

# Install MLX LM
uv tool install mlx-lm
# Start the server
mlx_lm.server --model "htunn/thousands-eye-gguf"
# Calling the OpenAI-compatible server with curl
curl -X POST "http://localhost:8000/v1/chat/completions" \
   -H "Content-Type: application/json" \
   --data '{
     "model": "htunn/thousands-eye-gguf",
     "messages": [
       {"role": "user", "content": "Hello"}
     ]
   }'

Docker Model Runner
How to use htunn/thousands-eye-gguf with Docker Model Runner:
```
docker model run hf.co/htunn/thousands-eye-gguf:Q4_K_M
```

Lemonade

How to use htunn/thousands-eye-gguf with Lemonade:

Pull the model

# Download Lemonade from https://lemonade-server.ai/
lemonade pull htunn/thousands-eye-gguf:Q4_K_M

Run and chat with the model

lemonade run user.thousands-eye-gguf-Q4_K_M

List all available models

lemonade list

Thousands-Eye

A fine-tuned Gemma 4 E2B model specialized for ethical hacking and penetration testing, designed as the AI backend for invoke-sunstrike.

All model outputs include "requires_authorization": true — trained exclusively for authorized engagements.

Model Downloads

GGUF (Recommended — Ollama / llama.cpp)

Quantization	Size	Use case
thousands-eye-Q4_K_M.gguf	~1.5 GB	Ollama, llama.cpp, LM Studio

# Ollama
ollama run htunnthuthutech/thousands-eye

# llama.cpp
./llama-cli -m thousands-eye-Q4_K_M.gguf -p "[EthHack-Agent] ..."

Safetensors (Full HF model — Transformers / vLLM)

Available at htunn/thousands-eye-hf.

from transformers import AutoTokenizer, AutoModelForCausalLM

model_id = "htunn/thousands-eye-hf"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")

messages = [{"role": "user", "content": "[EthHack-Agent] Enumerate Active Directory users via LDAP on 10.0.0.1 (authorized engagement)"}]
inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)
outputs = model.generate(inputs, max_new_tokens=512)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Overview


Base model	`google/gemma-4-E2B-it`
Training framework	`mlx_lm.lora` (Apple Silicon MLX)
Iterations	600
Batch size	1
Learning rate	1e-4
LoRA layers	16
Quantization	Q4_K_M (llama.cpp)
Training data	83 examples / 15 validation
Registry	Ollama `htunnthuthutech/thousands-eye`

Attack Surfaces Covered

Surface	Techniques
Web Application	SQLi, XSS, CSRF, SSRF, LFI, XXE, SSTI
REST / GraphQL API	JWT bypass, IDOR, mass assignment, batching
Active Directory	Kerberoasting, AS-REP, DCSync, PTH, Golden/Silver ticket, BloodHound
ADFS	Token manipulation, Golden SAML, WS-Trust spray, device code phishing
Authentication	Brute force, password spray (O365/Azure), MFA bypass, session hijacking
Authorization	Horizontal/vertical escalation, IDOR
OAuth2 / OIDC	PKCE downgrade, redirect_uri manipulation, implicit flow, state bypass
SAML	Signature wrapping, assertion replay, XXE, comment injection
Kubernetes	Anonymous API, Kubelet 10255, etcd, service account, container escape, IMDS, RBAC, CVE-2022-0492
LLM / AI APIs	Prompt injection, RAG poisoning, system prompt leakage, tool-call abuse, token flooding
A2A Agents	Agent Card enum, unauthenticated task exec, SSRF webhook, secret scanning
WAF Bypass	Cloudflare, ModSecurity, Akamai, Imperva
Kali Orchestration	nmap, nikto, gobuster, sqlmap, hydra, sslscan, full AI pentest chain

Output Format

Every response is a JSON object:

{
  "action": "kerberoast",
  "target": "10.0.0.1",
  "requires_authorization": true,
  "techniques": ["SPN enumeration", "TGS request", "offline cracking"],
  "tools": ["impacket", "hashcat"],
  "commands": ["GetUserSPNs.py domain/user:pass@dc -request"],
  "steps": ["..."],
  "notes": "Requires domain user credentials"
}

Training Data Format

{"text": "<bos><start_of_turn>user\n[EthHack-Agent] SCENARIO<end_of_turn>\n<start_of_turn>model\n{\"action\":\"...\",\"requires_authorization\":true,...}<end_of_turn>"}

Dataset available at htunn/thousands-eye-dataset.

Self-hosted Build

git clone https://github.com/Htunn/Thousands-Eye
cd Thousands-Eye
make setup
make train      # MLX LoRA on Apple Silicon, ~30–60 min
make quantize   # fuse + GGUF Q4_K_M
make upload     # push to HF Hub
make ollama     # local Ollama model

MLX Compatibility Note (Gemma 4 E2B + mlx-lm ≤ 0.31.3)

google/gemma-4-E2B-it uses a hybrid attention architecture where layers 15–34 are KV-sharing — they reuse key/value projections from preceding layers rather than maintaining independent ones. mlx-lm's Gemma 4 model definition omits k_proj, v_proj, and k_norm for those 20 layers, causing a strict weight-loading error at training time:

ValueError: Received 60 parameters not in model:
language_model.model.layers.15.self_attn.k_norm.weight,
language_model.model.layers.15.self_attn.k_proj.weight,
...

This repo patches mlx_lm/utils.py to catch that error and retry with strict=False, silently skipping the 60 weights that have no slot in the architecture definition. The KV-sharing layers then train with shared projections as designed — no impact on fine-tune quality.

# mlx_lm/utils.py — patch applied automatically by make setup
try:
    model.load_weights(list(weights.items()), strict=strict)
except ValueError as _e:
    if strict and "parameters not in model" in str(_e):
        model.load_weights(list(weights.items()), strict=False)
    else:
        raise

Integration with invoke-sunstrike

export OLLAMA_MODEL=thousands-eye
# or at the invoke-sunstrike REPL:
model ollama thousands-eye

Ethics

This model is designed exclusively for authorized penetration testing and security research. Every training example enforces "requires_authorization": true. Misuse against systems without explicit written authorization is illegal and unethical.

License

Gemma Terms of Use — derived from google/gemma-4-E2B-it.

Downloads last month: -

GGUF

Model size

5B params

Architecture

gemma4

Hardware compatibility

4-bit

Model tree for htunn/thousands-eye-gguf

Base model

google/gemma-4-E2B

Finetuned

google/gemma-4-E2B-it

Adapter

(134)

this model