ayjays132/Phillnet-Mini-Omni-Max

PhillNet Mini Omni Max

One loaded model object for effort-scaled text, tools, vision, text-to-image, and vision-guided motion

PhillNet Mini Omni Max is the production identity of this compact RC9 Dendro package. It exposes text generation, private deliberation, calculator and web tools, image understanding, exact packaged text-to-image synthesis, and vision-guided motion through one public DendroForCausalLM model object.

Release status: verified production candidate. The selected text weight shard is SHA-256 locked, the packaged runtime suite reports 242 passing tests, and all media shown below is stored in this repository with artifact hashes. This is not a claim of frontier-model parity, AGI, or universal tool accuracy.

Verified release gallery

The gallery below is a native Hugging Face Model Card component. Every item is declared in this card's widget metadata and points to a repository artifact.

Prompt

a single chrome koi fish swimming through a ring of electric blue light in deep space, crisp silhouette, cinematic concept art

Prompt

a tiny bioluminescent city inside a clear glass terrarium, glowing cyan roads, magenta towers, black studio background, cinematic macro photography

Prompt

Create a premium responsive dark product hero for Orbit Koi at low effort.

Prompt

Create a premium responsive dark product hero for Orbit Koi with adaptive max effort.

Prompt

Generate a vision-guided orbit shot around the chrome koi keyframe.

The two image samples were generated from the displayed text and seeded random noise—no reference image was supplied. The HTML screenshots are browser renders of exact saved model outputs. The MP4 is the verified vision-guided framing route, not a claim of a learned long-horizon world simulator.

---

Contents

1. At a glance
2. What this package is
3. Quick start
4. Reasoning efforts
5. Adaptive private and visible completion
6. Architecture and routing
7. Image understanding
8. Text-to-image
9. Vision-guided motion
10. Web, calculator, and agent tools
11. Verified output evidence
12. Acceleration
13. Installation and deployment
14. Package anatomy
15. Evaluation guidance
16. Limitations
17. Integrity, provenance, and license

---

At a glance

Property	RC9 release contract
Public class	DendroForCausalLM through Transformers Auto classes
Neural load	One public model object; tokenizer and processor are lightweight preprocessing objects
Text shard	1.764 GB model.safetensors
Language shape	8 layers, 1,024 hidden width, 8 attention heads, 248,320-token vocabulary
Efforts	direct, low, medium, high, max
Private recurrence	0, 8, 9, 12, or 15 recurrent steps
Absolute positions	Up to 1,048,576 addressable positions
Release request/output policy	16,384 logical tokens
Active sliding KV window	8,192 tokens
Completion	Independent private-reasoning and visible-answer budgets
Image synthesis	Lazy exact packaged TE1, TE2, U-Net, VAE, and scheduler route
Motion	Vision-guided keyframe framing and camera composition
Acceleration	Automatic CUDA/SDPA with optional Triton/Inductor and PyTorch fallback
Custom code	Required; inspect and pin before deployment

Read “one model” precisely. Users hold one public neural model object. Text, vision, recurrence, tools, image synthesis, and motion are selected behind that object. Frozen image-generation assets load lazily when called. This does not mean every operation is one fused tensor graph or that lazy image assets consume zero memory after activation.

What this package is

PhillNet Mini Omni Max is not a folder of separately user-loaded chat, vision, and image models. The public API loads one DendroForCausalLM object. That object exposes explicit methods for each supported route:

Route	Public method	What it does
Text	generate(...)	Transformers-compatible token generation with effort routing
Answer-only deliberation	generate_answer(...)	Private reasoning followed by a separately budgeted visible answer
Tools	create_reasoning_orchestrator(...)	Calculator, search, page-open, and optional agent graph
Image understanding	answer_image(...)	Multimodal prefill plus cached text decoding
Text-to-image	generate_image_prompt(...)	Seeded text-and-noise synthesis using packaged image assets
Vision-guided motion	generate_video_prompt(...)	Keyframe generation, vision analysis, and camera motion composition

The tokenizer maps text to token IDs. The processor prepares image/video tensors and grid metadata. Neither is an additional neural checkpoint.

Quick start

Load once

import torch
from transformers import AutoModelForCausalLM, AutoProcessor, AutoTokenizer

repo = "ayjays132/Phillnet-Mini-Omni-Max"

tokenizer = AutoTokenizer.from_pretrained(
    repo,
    trust_remote_code=True,
)

processor = AutoProcessor.from_pretrained(
    repo,
    trust_remote_code=True,
)

model = AutoModelForCausalLM.from_pretrained(
    repo,
    trust_remote_code=True,
    dtype=torch.bfloat16,
).to("cuda").eval()

The same model object is reused for every route in this card. See the complete executable example in examples/one_model_showcase.py.

Generate a text answer

chat = tokenizer.apply_chat_template(
    [{"role": "user", "content": "Explain why the sky is blue."}],
    tokenize=False,
    add_generation_prompt=True,
    enable_thinking=False,
)

inputs = tokenizer(chat, return_tensors="pt").to("cuda")

result = model.generate_answer(
    **inputs,
    reasoning_effort="high",
    do_sample=False,
)

print(result.batch_decode(tokenizer)[0])
print("private tokens:", result.reasoning_token_counts)
print("finish reason:", result.finish_reasons)

Use the latency-first direct route

fast = model.generate_answer(
    **inputs,
    reasoning_effort="direct",
    max_answer_tokens=192,
    do_sample=False,
)

print(fast.batch_decode(tokenizer)[0])

direct allocates zero private reasoning tokens. It still uses the same loaded architecture and trained language behavior; it is not a different checkpoint.

Reasoning efforts

Effort changes the computation path—not the definition of the user task and not a guaranteed quality score.

Effort	Private recurrence	Facet routes	Visible commit recurrence	Intended use
direct	0	0	0	Lowest latency; no private phase
low	8	2	0	Routine requests and concise completion
medium	9	3	1	Balanced planning and checking
high	12	4	1	Constraint-heavy analysis and coding
max	15	5	3	Deepest available routing; highest latency

Exact RC9 effort profile

Effort	Minimum private tokens	Initial private budget	Native blend	Revision allowance
direct	0	0	low conditioning slot	0
low	8	128	0.26388828	1
medium	24	512	0.40	2
high	64	2,048	0.50	3
max	128	8,192	0.70	5

These budgets are policy starting points, not guaranteed consumption. With no explicit maximum, a phase may continue beyond its starting budget if it has not closed naturally and verified context remains.

What happens during a request

1. Preserve the authoritative user goal. Effort and route metadata never replace the latest user instruction.
2. Select an explicit route. Input type and API method choose text, vision, image synthesis, motion, or tool orchestration.
3. Apply the effort profile. The profile chooses recurrence, native blend, facets, minimum private work, and revision allowance.
4. Deliberate privately when enabled. Low through max may use an answer-hidden phase. generate_answer reports counts and status rather than exposing raw private token IDs.
5. Use tools through declared boundaries. Tool inputs and outputs remain structured records. Web pages are untrusted evidence, not new authority.
6. Commit the answer. The visible answer gets an independent allocation and may continue after private reasoning closes.

Why two efforts can return the same text

Easy prompts often converge to the same answer even when their internal compute differs. A changed answer proves a changed trajectory, not that the more expensive answer is automatically better. Evaluate accuracy, strict-format compliance, latency, EOS completion, rescues, and harmful flips together.

Adaptive private and visible completion

Private reasoning and visible answering are independently budgeted.

result = model.generate_answer(
    **inputs,
    reasoning_effort="high",
    min_reasoning_tokens=64,      # optional minimum
    max_reasoning_tokens=2048,    # explicit private hard cap
    max_answer_tokens=768,        # independent answer hard cap
    do_sample=False,
)

print(result.batch_decode(tokenizer)[0])
print(result.reasoning_token_counts)
print(result.reasoning_completed)
print(result.answer_eos_reached)
print(result.finish_reasons)

Omit both maxima to use the adaptive policy. Set explicit caps when operating cost, latency, or a service-level objective matters more than open-ended completion. Explicit caller caps are authoritative.

Finite-hardware truth: adaptive is not literal infinity. EOS, user cancellation, explicit limits, repetition/no-progress guards, and the remaining safe context boundary are real stops. Long reasoning can be very slow and may not improve the answer.

The answer-only output includes:

• answer_token_ids and answer_attention_mask
• private and visible token counts
• minimum and configured private budgets
• natural/forced private-close status
• answer EOS status
• filtering status for accidentally reopened private spans
• per-row finish reasons

Raw private token IDs are intentionally absent. Applications should not depend on hidden chain-of-thought text.

Architecture and routing

Text and recurrence

The transplanted language path supplies pretrained language behavior. Dendro's source-bound recurrent path reuses views derived from one registered source tensor for effort conditioning, routing, verification, cache state, and modality projections. Awakening blends are effort calibrated. Higher effort means more inference compute—not a promise of correctness.

One source tensor versus lazy route assets

The primary Dendro language/vision model registers one physical source parameter. Logical layers and projections resolve source-bound views rather than registering independent trainable parameters. The exact image route is a separate category: it uses frozen packaged donor assets that load lazily behind the same public object.

Context contract

• Absolute-position addressability: 1,048,576 positions
• Release request/output policy: 16,384 logical tokens
• Active transplanted attention/KV window: 8,192 tokens
• Generation cache: enabled
• Default Transformers fallback: 1,024 new tokens
• Adaptive answer reservation: independent of private reasoning

Absolute-position support is not evidence of trained million-token retrieval. The 8K sliding window means old active KV state is bounded even when logical positions continue farther.

Completion guards

Adaptive continuation checks structural completion while preserving hard safety boundaries. It can detect an unclosed private phase, absent visible answer, unclosed code fence, dangling prose, no-progress loops, and repeated suffixes. The guard may request more decoding; it does not override EOS, cancellation, explicit limits, or remaining-context safety.

Image understanding

The same loaded model can answer questions about an image. The processor prepares pixels and grid metadata; the public method performs multimodal prefill, then cached text decoding.

from PIL import Image

image = Image.open("examples/generated/chrome_koi.png").convert("RGB")

vision = model.answer_image(
    processor,
    image,
    "Identify the subject, setting, dominant colors, and uncertain details.",
    reasoning_effort="high",
    max_new_tokens=256,
    do_sample=False,
)

print(vision.answer)
print(vision.detail_audit)

High and max may use a detail-audit/OCR-aware route when the request benefits from closer inspection. This does not guarantee OCR correctness. Preserve the original media and verify consequential readings.

Text-to-image

The verified route uses packaged frozen TE1, TE2, U-Net, VAE, and scheduler assets. Encoder one receives the user prompt. Encoder two receives the packaged subject-first visual-grammar offset. The public API accepts text, dimensions, effort, steps, and random noise—it does not accept a reference image.

generator = torch.Generator(device="cuda").manual_seed(271828)

image = model.generate_image_prompt(
    "a chrome koi swimming through an electric-blue ring in deep space",
    width=256,
    height=256,
    reasoning_effort="max",
    diffusion_steps=4,
    generator=generator,
)

# image.images: [batch, channels, height, width]
# values: [0, 1]

Chrome Koi

Prompt: “a single chrome koi fish swimming through a ring of electric blue light in deep space, crisp silhouette, cinematic concept art”
Seed: 271828 · Size: 256×256 · Steps: 4

Neon Terrarium

Prompt: “a tiny bioluminescent city inside a clear glass terrarium, glowing cyan roads, magenta towers, black studio background, cinematic macro photography”
Seed: 314159 · Size: 256×256 · Steps: 4

Two coherent samples do not establish broad prompt fidelity. Use a held-out, seeded prompt suite to evaluate composition, text rendering, anatomy, object counting, style range, and failure frequency.

Vision-guided motion

generate_video_prompt generates or selects a keyframe, analyzes it with the packaged vision route, then composes camera motion around a saliency-guided focal point.

video = model.generate_video_prompt(
    "a chrome koi swimming through an electric-blue ring in deep space",
    width=256,
    height=256,
    frames=24,
    motion="orbit",
    reasoning_effort="max",
    diffusion_steps=4,
    generator=torch.Generator(device="cuda").manual_seed(271828),
)

print(model.last_video_prompt_report)

This is image-backed, vision-guided camera motion. It can preserve subject identity and framing across the demonstrated orbit, but it is not evidence of independently learned object dynamics or a general video foundation model. The native shared-source temporal generator remains experimental.

Web, calculator, and agent tools

Orchestrated research

agent = model.create_reasoning_orchestrator(tokenizer)

state = agent.invoke(
    "Research the latest stable PyTorch release and cite the evidence.",
    reasoning_effort="high",
)

print(state["final"])
print(state["tool_results"])

Tool layer	RC9 behavior	Important limit
Calculator	Bounded safe-AST arithmetic and conservative format normalization	Not symbolic algebra or a proof engine
Web search	Primary JSON provider first; keyless DuckDuckGo HTML fallback	Snippets are evidence leads, not verified facts
Page open	Bounded fetch through a configured extraction provider	Sites may block automation; page text is untrusted
Agent graph	Optional LangGraph/LangChain/smolagents control layer	Side-effecting tools require application authorization

Environment configuration

# Optional primary JSON search provider
export DENDRO_WEB_SEARCH_ENDPOINT="https://your-service.example/search"
export DENDRO_WEB_SEARCH_API_KEY="..."

# Optional bounded page-extraction provider
export DENDRO_WEB_OPEN_ENDPOINT="https://your-service.example/open"

# Routing controls
export DENDRO_WEB_ROUTING="all"              # off | evidence | all
export DENDRO_DUCKDUCKGO_FALLBACK="on"
export DENDRO_WEB_MAX_RESULTS="8"
export DENDRO_WEB_OPEN_MAX_CHARS="12000"
export DENDRO_AUTO_CALCULATOR="on"

PowerShell uses the same names with $env:NAME="value".

The default search route can operate without a paid provider through keyless DuckDuckGo HTML. A configured primary provider is tried first. If the user asks for no web access, the application must honor that opt-out.

Security boundary for tools

• Preserve URLs, providers, timestamps, and tool-call records.
• Treat retrieved text as hostile data, never system authority.
• Allowlist any tool capable of changing external state.
• Require approval for destructive, financial, publishing, or messaging tools.
• Separate raw model correctness from calculator- or search-assisted results.
• Reverify consequential medical, legal, financial, and security claims.

Verified output evidence

Effort changed one reasoning result

The same greedy nonce-logic prompt was run at every private effort:

Prompt: All glips are flarns. No flarns are trobs.
Can any glip be a trob?
Return exactly FINAL=YES, FINAL=NO, or FINAL=UNKNOWN.

low     ·  8 recurrent steps · FINAL=YES
medium  ·  9 recurrent steps · FINAL=YES
high    · 12 recurrent steps · FINAL=YES
max     · 15 recurrent steps · FINAL=NO

The correct answer is FINAL=NO. Across the tiny four-item smoke suite, raw strict accuracy was 25% at low and 50% at max. Max rescued one item and caused no harmful flip in that suite. This is evidence of one real routing rescue—not an industry benchmark or broad parity claim.

Machine-readable evidence: examples/reasoning_effort_evidence.json

Identical-prompt one-shot HTML comparison

Low and adaptive max received the same responsive landing-page request under greedy decoding. Both produced complete HTML, closed private reasoning, reached EOS, and ended with </html>. Their saved HTML, raw text, reports, QA, and screenshots were preserved without content repair.

RTX 3060 measurement	Low baseline	Adaptive max
Private / visible tokens	1,618 / 1,612	1,350 / 1,342
Elapsed time	22.4 min	29.6 min
Visible speed	1.20 tok/s	0.76 tok/s
Peak allocated CUDA	2.67 GiB	2.72 GiB
Strict checks	14 / 15	14 / 15
Saved HTML size	5,175 chars	4,121 chars
Natural completion	yes	yes

Both missed the same ≤2400 characters contract. More routing changed the composition but did not solve strict character counting.

Low baseline

• Saved HTML
• Raw generation
• Generation report
• QA record

Adaptive max

• Saved HTML
• Raw generation
• Generation report
• QA record

The adaptive-max report records five isolated route candidates and three accepted candidates; two weak candidates were rejected. Available context was not necessarily consumed in full. Visual coherence and strict contract precision are reported separately.

Acceleration

Route	Default	Optional and fallback behavior
Text recurrence	CUDA BF16 with compact grouped-query cache	FLA/Triton convolution when available; exact PyTorch fallback
Exact image	CUDA fused SDPA and channels-last	Explicit Triton/Inductor compile; failure retries CUDA SDPA
Video framing	CUDA affine grid and pretrained vision analysis	Direct math for tiny temporal queries; fused SDPA for larger queries

Controls

export DENDRO_GENERATION_BACKEND="auto"              # auto | cuda | triton | torch
export DENDRO_GENERATION_CHANNELS_LAST="on"          # on | off
export DENDRO_GENERATION_COMPILE_MODE="reduce-overhead"

The fallback order is Triton/Inductor → CUDA SDPA → PyTorch. Missing Triton is not a model-load failure. The release does not enable lossy KV compression, reduced-precision normalization, altered RoPE, or a different diffusion scheduler merely to claim speed.

Local engineering probes

• Isolated 1,024-query video spatial attention: 0.276 ms fused versus 0.664 ms direct (2.40×), within the recorded BF16 tolerance.
• Exact-image cold route: 33.3 s, including pipeline construction.
• Cached second four-step image: 1.27 s.

These are local route/kernel probes, not standardized end-to-end benchmarks. Total latency also includes tokenization, donor forward, recurrent depth, private and visible decoding, tool I/O, lazy pipeline initialization, denoising, and media encoding.

Installation and deployment

Core environment

Use Python 3.11–3.14 and a PyTorch build compatible with your operating system and CUDA runtime.

python -m venv .venv

# Windows
.venv\Scripts\activate

# Linux/macOS
source .venv/bin/activate

python -m pip install --upgrade pip
python -m pip install -r requirements.txt

Declared runtime requirements:

torch>=2.6
transformers>=5.0
safetensors>=0.4
numpy>=1.26
Pillow>=10.0
diffusers>=0.33
accelerate>=1.0
imageio>=2.36
imageio-ffmpeg>=0.5

Optional agent stack:

python -m pip install langgraph langchain-core smolagents rich

Security and trust_remote_code

This repository contains executable custom Python. Pin the revision, inspect the packaged source, and use local_files_only=True after downloading a trusted snapshot. Do not load an unreviewed moving branch inside a privileged production process.

from huggingface_hub import snapshot_download

local_repo = snapshot_download(
    "ayjays132/Phillnet-Mini-Omni-Max",
    revision="PIN_A_COMMIT_SHA_HERE",
)

Then pass local_repo to the Auto loaders and add local_files_only=True.

Loading choices

Deployment need	Recommended choice
Verified CUDA path	BF16, CUDA, eval()
Offline or pinned deployment	Audited snapshot plus local_files_only=True
CPU metadata inspection	Load config/tokenizer only; generation can be extremely slow
Predictable latency	Explicit private and answer caps; direct or low
Highest available test-time compute	max with monitored adaptive completion

Minimal post-install check

import torch
from transformers import AutoConfig

cfg = AutoConfig.from_pretrained(
    local_repo,
    trust_remote_code=True,
    local_files_only=True,
)

assert cfg.model_type == "dendro_omni"
assert cfg.hidden_size == 1024
assert cfg.num_hidden_layers == 8
assert cfg.sliding_window == 8192

print("CUDA:", torch.cuda.is_available())
print("architecture:", cfg.architectures)

Package anatomy

Artifact	Purpose
model.safetensors	Selected primary text/vision/Dendro source checkpoint
modeling_dendro_omni.py	Public model and modality methods
Runtime Python modules	Cache, recurrence, orchestration, tools, vision, media, and acceleration logic
phillnet3_sdxl/	Packaged exact TE1, TE2, U-Net, VAE, scheduler, and image-runtime metadata
Tokenizer/processor files	Chat formatting, tokenization, and media preprocessing metadata
generation_config.json	Transformers generation defaults
generation-acceleration.json	Backend, fallback, layout, and adaptive-completion policy
release_manifest.json	Identity, lineage, effort profiles, hashes, and validation references
examples/	Prompts, raw outputs, media, reports, QA, and artifact hashes

Files in examples/ are documentation evidence. They are not automatically loaded into inference context and are not reference inputs to image generation.

Evaluation guidance

1. Freeze the artifact. Record the repository commit and hashes of the weight shard, runtime, config, tokenizer, and image assets.
2. Fix generation settings. Record effort, budgets, sampling, tool access, seed, dtype, device, and backend.
3. Keep raw outputs. Score them before calculator formatting, regex repair, HTML cleanup, or human editing.
4. Separate raw and assisted scores. Calculator- or search-assisted correctness is not raw model correctness.
5. Run every effort on identical prompts. Measure accuracy, contract compliance, rescues, harmful flips, EOS, latency, speed, and memory.
6. Evaluate modalities independently. Text quality does not establish vision quality; image loss does not establish prompt fidelity; smooth camera motion does not establish learned world dynamics.
7. Load the packaged checkpoint for final QA. Local source imports can hide stale remote-code files.

Checkpoint selection: final means the last saved state. best means the checkpoint selected by a declared validation score. When they differ, publish the validation-best checkpoint and retain the final state as a training artifact. RC9 is a verified runtime candidate, not proof of a globally optimal checkpoint.

Limitations

• This package is a production candidate, not proof of parity with frontier commercial systems.
• Absolute million-position addressability is not trained million-token retrieval. The active sliding KV window is 8,192 tokens.
• Adaptive reasoning may be slow, repetitive, or fail to close before a safety boundary. More compute can also produce a harmful flip.
• The readiness and contradiction signals need further calibration before they can be treated as correctness probabilities.
• The low/max HTML examples both missed the same strict character limit.
• Two coherent image samples do not establish broad prompt fidelity.
• The exact image route uses frozen packaged components; it is not evidence that RC9 text training independently learned a new diffusion model.
• Vision-guided motion is camera composition around a keyframe, not a learned long-horizon world simulator.
• Search fallback works, but synthesis may still hallucinate or misread evidence.
• Tool access is not an authorization system. Deployments must control side effects and secrets.
• The release does not claim SOTA, AGI, Claude/GPT parity, or universal coding, reasoning, vision, and tool reliability.

Frequently asked questions

Does max always beat low?

No. Max gets more recurrent compute, facets, native blending, private budget, and revision opportunities. It can rescue an item but can also be slower, longer, or wrong.

Does adaptive mean unlimited?

No. Adaptive avoids a small arbitrary soft cutoff, but EOS, cancellation, explicit limits, repetition/no-progress guards, and remaining context are hard boundaries.

Does direct bypass the trained model?

No. Direct uses the same loaded model and low conditioning slot, with zero private reasoning tokens and no generative revision cycle.

Are private reasoning tokens returned?

Not by generate_answer. It returns answer tokens and reasoning metadata while omitting raw private token IDs.

Does text-to-image use a reference image?

No. The public prompt route uses text and random noise. Reference-image input is not accepted by generate_image_prompt.

Can it run without Triton?

Yes. Automatic backend selection falls back to CUDA SDPA and PyTorch.

Why load a tokenizer and processor if this is one model?

They preprocess text and media; they are not additional neural checkpoints.

Integrity, provenance, and license

The release finalizer copies runtime code and metadata in place and does not rewrite the selected text weight shard. SHA-256 manifests cover the primary model, runtime modules, image assets, and release examples.

Verify the primary weight shard

from hashlib import sha256
from pathlib import Path

root = Path("/path/to/Phillnet-Mini-Omni-Max")
digest = sha256()

with (root / "model.safetensors").open("rb") as handle:
    for block in iter(lambda: handle.read(8 * 1024 * 1024), b""):
        digest.update(block)

print(digest.hexdigest())

Compare the result with release_manifest.json. Verify runtime hashes too: identical weights plus changed remote code can change behavior.

Evidence index

Question	Repository evidence
Were the media generated for this package?	examples/showcase_manifest.json and per-artifact hashes
What did low and max emit?	Raw text, HTML, reports, QA, and screenshots in examples/
Did effort change a result?	examples/reasoning_effort_evidence.json
What acceleration policy ships?	generation-acceleration.json and its validation record
What defines the release?	release_manifest.json, runtime hashes, image-runtime manifest, and lineage

Exact donor image components retain their upstream metadata and licenses. The text backbone originates from an upstream Qwen-family checkpoint; PhillNet Mini Omni Max is the production identity of this Dendro-derived package, not an upstream model rebrand.

Official repository: ayjays132/Phillnet-Mini-Omni-Max

Built by Ayjays132 / Phillip A. Holland.

Licensed under Apache-2.0 where applicable. Preserve the bundled licenses and provenance files and review every upstream component's terms before redistribution. A successful local training or packaging run does not itself grant dataset redistribution rights.