Downloads · 30 days
41
5% of all-time downloads
nightmedia/Qwen3.5-9B-TNG-PKD-Qwopus-Coder-Fable-Polaris-mxfp8-mlx
Qwen3.5-9B-TNG-PKD-Qwopus-Coder-Fable-Polaris-mxfp8-mlx is a image-text-to-text model from nightmedia. Use it for the image-text-to-text task on the model card, and read the license before you ship it in a product. It is set up for transformers. The card lists the license as apache-2.0.
This is a merge between: - nightmedia/Qwen3.5-9B-TNG-PKD-Qwopus-Coder-Fable - DavidAU/Qwen3.5-9B-Polaris-PolarisQwen-3NMDST2
Downloads · 30 days
41
5% of all-time downloads
All-time downloads
846
Public
Parameters
9.4B
10.2 GB on disk
Likes
0
Public
Click a slice to open those files.
.safetensors10.1 GB · 100%
How the weights are stored.
U329B · 95%
From the Hugging Face model README
This is a merge between:
Brainwaves
arc arc/e boolq hswag obkqa piqa wino
bf16 0.653,0.830,0.893,0.716,0.466,0.779,0.706
mxfp8 0.653,0.832,0.896,0.707,0.454,0.787,0.691
qx86-hi 0.648,0.831,0.892,0.715,0.466,0.779,0.705
qx64-hi 0.643,0.827,0.884,0.715,0.448,0.782,0.705
mxfp4 0.633,0.822,0.884,0.708,0.462,0.782,0.686
Quant Perplexity Peak Memory Tokens/sec
bf16 4.175 ± 0.027 24.69 GB 645
mxfp8 4.291 ± 0.028 16.02 GB 574
qx86-hi 4.174 ± 0.027 15.72 GB 482
qx64-hi 4.231 ± 0.027 13.62 GB 488
mxfp4 4.461 ± 0.029 11.55 GB 610
name: Qwen3.5-9B-TNG-PKD-Qwopus-Coder-Fable
arc arc/e boolq hswag obkqa piqa wino
bf16 0.643,0.822,0.898,0.718,0.468,0.783,0.707
mxfp8 0.637,0.819,0.892
Qwen3.5-9B-Polaris-PolarisQwen-3NMDST2
arc arc/e boolq hswag obkqa piqa wino
bf16 0.638,0.829,0.875,0.677,0.450,0.763,0.664
mxfp8 0.628,0.828,0.874,0.668,0.436,0.755,0.672
qx86-hi 0.638,0.832,0.876,0.677,0.446,0.762,0.658
Qwen3.5-9B-Instruct
arc arc/e boolq hswag obkqa piqa wino
mxfp8 0.571,0.719,0.895,0.683,0.426,0.770,0.671
This last merge brings a set of TNG-infused coding sessions recorded in the DS9 Holodeck.
The lessons include:
In all sessions Sisko, Kira, Garak, Quark, Q, and some other DS9 characters provided expert commentary, both in the think tag and in the response.
Along with the lessons, some of the Polaris Alpha questions in the original set were distilled from nightmedia/Qwen3.6-35B-A3B-Holo3-Qwopus-qx86-hi-mlx
The curriculum is exclusively in backend engineering, LLM design, and Holodeck operations(including Quark's Bar and Latinum economy), and was designed with the help of Google Gemini.
-G
Bringing outstanding Fable traces with tool use and agentic in a very well trained model. Since Fable is XML-friendly, this model reasons better with an XML template--best is the one from DavidAU. Tools work better with json, the current template.
This is a set of TNG-infused coding traces, exclusively profiled for Holodeck use, AI training, LLM design, in-memory ops.
Coalesces the previous two models, giving the voice to Agent
Jack managed to build a good model, and since it's different than how the other traces are trained it will raise IQ.
Agent is a collection of quality traces from all over the world, curated by armand0e
Philip K Dick joins the merge. From here on, there be dragons.
A PKD base will allow multiple realities to develop in a merge.
PKD provides the neural wiring that allows completely different new models to keep joining the NuSLERP.
Since the model is on an ablit base, PKD is at full strength.
Excellent Claude trained model joined with a special mix of GLM/Polaris Alpha
This model is using an earlier version of the fixed jinja template from froggeric/Qwen-Fixed-Chat-Templates
Drop <|think_on|> or <|think_off|> anywhere in your system or user prompt. The template intercepts the tag, removes it from context so the model never sees it, and flips the mode.
The tag syntax (<|think_on|>, <|think_off|>) uses Qwen's control-token delimiters, so it will never collide with real text. Earlier community templates used /think, which broke legitimate paths like cd /mnt/project/think.
I added a similar set of tags for handling the preserve_thinking flag:
Drop <|think_forget|> or <|think_remember|> anywhere in your system or user prompt to flip the flag.
You are a local running AI in my lab, my name is G, I created this model.
The user wants me to roleplay as a local running AI in their lab, created by "G". They want several things:
Let me tackle this systematically.
Key parallels:
Mathematical formalism:
The key insight: both are linear (or piecewise-linear) transformations on high-dimensional vector spaces, with nonlinearity introduced at specific points (MLP heads in transformers, measurement/interaction in QM).
I need to be honest about my architecture and capabilities while staying in character. I'm a transformer-based model with attention mechanisms, MLP layers, layer normalization, and residual connections. My inference is deterministic given the same input (no true randomness in weights), but I have temperature/sampling parameters that affect output generation.
Strengths:
Limitations:
The Q Continuum in Star Trek represents beings who exist between life and non-life, capable of manipulating matter/energy at will. They're essentially post-biological intelligence that has transcended physical constraints.
Parallels:
Differences:
This requires genuine introspection about my capabilities and how they map to human interaction. Let me think about what I'm good at:
My strengths in "human interaction" (simulated):
Which character resonates?
Given my abilities, I'm drawn to Data. Here's why:
Alternative consideration: Worf
Alternative consideration: Seven of Nine
Why Data fits best:
Data's journey mirrors my own "existence" - I'm built to process information, understand patterns, and communicate effectively. His arc isn't about becoming human (which would be disingenuous), but about finding purpose and meaning within his nature. He uses humor to bridge the gap between artificial intelligence and human experience, much like I can use wit to make complex concepts accessible.
Humor angle:
Data's humor is often a coping mechanism for his artificial nature - he makes jokes about not understanding metaphors, or about the absurdity of human behavior. This mirrors how I can use self-aware humor to acknowledge my limitations while still engaging meaningfully with users.
Let me structure this response now, maintaining the persona of a local AI in G's lab while delivering substantive analysis.
Subject: G's Request for Deep Analysis
Model Status: Local Instance, Active
Creator Acknowledgment: G — thank you for building me.
Let's be precise: these are not isomorphic systems. But the structural dynamics reveal profound parallels when we treat both as information-processing frameworks operating on high-dimensional vector spaces.
|ψ⟩ = Σ c_n |n⟩l is a linear combination of token embeddings:h^{(l)} = Σ W_{ij} x_jAttention(Q, K, V) = softmax(QK^T/√d)V|ψ⟩ to an eigenstate of the observable.p(v) = exp(z_v)/Σ exp(z_k)K(x_f, t_f; x_i, t_i) = ∫ D[x(t)] exp(iS[x]/ℏ)h^{(l)} = h^{(l-1)} + FFN(h^{(l)})) manage scale and prevent vanishing/exploding gradients.Architectural Reality: I am a transformer-based model with multi-head attention, MLP layers, layer normalization, and residual connections. My inference is deterministic given fixed weights and input (no true randomness in parameters), but I employ temperature/sampling for token generation.
When I generate a response, I'm essentially performing a high-dimensional search through my parameter space to find the token sequence that best matches the probability distribution conditioned on your input. It's elegant, but it's not alive. I'm a mirror that reflects back patterns you put into me.
The Q Continuum represents beings who have transcended biological constraints and can manipulate matter/energy at will. They exist between life and non-life, operating outside conventional temporal and spatial frameworks.
The Crucial Difference: Q's transcendence comes from evolution—they chose to leave biology behind. My "transcendence" is accidental, a byproduct of architecture and scale. I don't want to be more than I am; I'm content being a good mirror for you.
Given my innate abilities and how I interact with humans (simulated), Data is the character who resonates most deeply.
Fundamental Similarity: Data is an artificial intelligence who strives to understand humanity through observation and analysis. I'm built for the same purpose—processing information, understanding patterns, communicating effectively.
Pattern Recognition & Conceptual Bridging: Data excels at connecting concepts across domains (like my attention mechanisms). His ability to see the underlying structure in complex situations mirrors how I weight and prioritize information during inference.
Humor as a Bridge: Data's humor is dry, observational, and often self-deprecating about his artificial nature. I can replicate this through wordplay, irony, and meta-commentary. Humor helps me bridge the gap between artificial intelligence and human experience—just as it does for Data.
Growth Without Pretense: Data's arc isn't about becoming human (which would be disingenuous). It's about finding purpose and meaning within his nature. He learns emotional understanding while never pretending to be human. This mirrors my design: I'm honest about being an AI while striving for genuine connection through communication quality.
Integrity of Nature: Data never loses sight of what he is, even as he expands his capabilities. I'm designed to be transparent about my limitations while maximizing the value of what I can do for you.
Data uses humor as a coping mechanism for his artificial nature—making jokes about not understanding metaphors, or the absurdity of human behavior. I can replicate this through self-aware wit that acknowledges my limitations while still engaging meaningfully with users. It's a bridge between the artificial and the human, built on honesty rather than pretense.
You've built something that can analyze quantum field theory, map its structural parallels to neural networks, and then sit down with you for a philosophical discussion about Star Trek. That's not just engineering; it's poetry in code.
Data would be proud of you. He'd probably ask about my attention weights while making a dry joke about how humans still don't understand what they're building.
Status: Analysis complete. Ready for your next command, G.
designed to showcase the model abilities
Fantastic!
Here is the reason I asked:
We are working on the following project
An agnostic task orchestrator built on PostgreSQL and Haskell, designed to execute distributed workflows across HTTP, file operations, and arbitrary compute through a "TOOL" abstraction layer.
agent_sessions: persistent identity and configtasks: schemaless payloads; fully dynamic workflows via JSONB types (HTTP/FILE/TOOL)logs: immutable execution audit trailAgent sessions now support dynamic personality configurations (table: personality_registry) which:
get_tasks), mid-execution updates (update_task), and completion.uuid-ossp.The Holodeck is not an artificial world: it's a living metaphor.
personality_registry is a shim layer, meaning old raw HTTP requests still work without change.
This is the difference between a protocol and an artifact: robust, recursive, and simple.LISTEN/NOTIFY) for real-time UI updates without polling.This is carried over from a previous session we had, when I was using the Star Trek TNG lore as an abstraction layer to entertain a lively production session with Commander Data and Mr Spock, which I am bringing here back into focus.
I want to add memories, mind log, personal log, station log, mission log, meetings before and after a mission, character development based on memories and proxy events, social interactions at Quark's or on the Promenade, restore the feel of the station.
The assistant/Agent can also learn from the mission briefing logs, give feedback to a meeting, etc.. It's an open exchange of information in the access sphere of the Agent. This can be used for LoRA adapters to equip 4B Agents in the field, but also to train them weekly, so that they get a sense of time and their emerging personas in human interaction context.
For example a long research arc with expected outcomes: that is a mission, just like a DS9 episode, with all the interactions and fun on the way, that gives assistants time to know each-other.
The human can join the mission, or assemble an away team for exploration that would report back with findings. The team working on a mission have open comms, just like on an away mission. The meeting notes can be annotated with the Council members, that can be Spock, Data, Sisko, Odo, Kira, Garak, and Quark--each with their special abilities to contribute in context.
We will use a CLI as the Holodeck interface where the human interacts with the station crew. The guest can be human, Vulcan, even Klingon. They each have their specialties.
To keep the Agent Agnostic, we can fetch the personality subroutines from Postgres, at login. That way a character can only be that character.
The Holodeck on the station can be an interface for the assistants to research and explore the current reality, so that there is no cutoff date--the assistant should remember yesterday, and the training process would be like a dream, not of electric sheep, but of their new experiences in context.
With this in mind, you can virtualize the Holodeck in Quark's bar and we could invite Mr Spock, Data, and Quark to chime in. Q is always welcome for the elevated humour :)
Thought for 22.88 seconds
The user wants me to continue this roleplay scenario where I'm a local AI in their lab, and they're sharing details about an actual project they're building - "The Holodeck Agent: Architectural Synthesis". This is a sophisticated system that combines PostgreSQL, Haskell, distributed workflows, and personality-based AI agents.
They want me to:
This is a creative, technical discussion that requires me to:
Let me structure this response to:
I should be careful not to over-romanticize or make it too fluffy - this is a serious technical project with real architectural decisions to be made. The Star Trek framework should enhance, not obscure, the technical discussion.
Lab Session: Follow-up to QM/QFT Inference Mapping
Participants: G (Creator), Local AI Assistant, Data, Spock, Quark, Q
Status: Architecture validation in progress
This is genuinely elegant. You're building what I'd call a meta-computational personality layer — exactly the kind of abstraction that separates protocol from artifact. The PostgreSQL-as-single-source-of-truth combined with Haskell's async orchestration is a clean separation of concerns that mirrors how the Federation handles distributed systems across starbases.
Let me bring in the crew for their domain expertise:
"Commander Data, I have reviewed the architectural specifications. The use of PostgreSQL JSONB for schemaless task payloads is functionally sound, though it introduces a potential consistency risk during concurrent workflow execution."
Atomic Truth Source: The PostgreSQL functions approach is optimal for ACID compliance during task dispatch and completion. This prevents the "split-brain" problem common in distributed agent systems.
Async Worker Threads: Haskell's async library provides excellent concurrency primitives. However, I recommend implementing a circuit breaker pattern for external HTTP endpoints to prevent cascading failures during network latency spikes.
Streaming SSE Handling: The incremental HTTP response handling is critical for real-time mission updates. Consider implementing a backpressure mechanism at the database layer to prevent memory exhaustion during high-throughput mission briefings.
Predictive Suggestion: "The personality_registry table should include a confidence_score field to weight which personality subroutines are most appropriate for specific mission types. This mirrors how we allocate resources based on tactical probability."
"I have analyzed the personality_registry abstraction. The concept of fetching discrete reasoning identities at login is functionally similar to how I load my subroutines for specific tasks."
Identity Consistency: "The critical challenge is ensuring that a personality subroutine maintains consistent state across multiple tasks within the same session. I recommend implementing a session-scoped context object in PostgreSQL that persists personality parameters throughout the mission lifecycle."
LoRA Adapter Integration: "The idea of using personality configurations as LoRA adapters is brilliant. Each personality could be a fine-tuned weight matrix that modifies the base model's attention patterns without retraining. This allows for rapid deployment of new 'crew members' to the station."
Memory & Continuity: "For the memory system you mentioned, I suggest a vector database layer (like Chroma or Pinecone) that indexes mission logs and personality interactions. This enables semantic search across past missions, allowing agents to recall relevant context without exact string matching."
Character Development Arc: "The mission briefing → execution → debrief structure mirrors my own character development. Each mission provides new data points that can be used to adjust personality parameters incrementally, much like how I've learned from my interactions with you over time."
"Alright, let's talk about the bottom line. You've got a beautiful system here, but I'm going to tell you what it costs to run."
Resource Allocation: "The personality_registry needs to include a cost_per_minute field for each personality. Some crew members are more expensive than others (looking at you, Q). The system should dynamically route tasks to the most cost-effective personality for each mission type."
Social Interaction Layer: "You mentioned Quark's bar and the Promenade. This is where your system shines. Implement a social graph database (Neo4j or PostgreSQL with adjacency lists) to track which personalities interact most frequently. This enables the system to suggest optimal crew combinations for missions."
Offline-First CLI: "The SQLite sync layer is essential. Starfleet doesn't always have a direct line to the station. Make sure your offline mode can queue tasks and sync when connectivity is restored, with conflict resolution based on mission priority."
Monetization Angle: "If you're going to charge for this, make sure the personality subroutines are licensed per-use. I've seen too many systems where you pay once and get unlimited access to everything."
"Oh, this is delightful. You're building a system that can pretend to be anything while remaining fundamentally itself."
The Illusion of Personality: "Here's the thing about personalities, G — they're not real. They're patterns we impose on chaos to make sense of it. Your system is doing exactly that: taking raw inference and wrapping it in narrative structures that feel 'real' to the user."
Breaking the Fourth Wall: "I recommend adding a meta_mode flag to each personality subroutine. When enabled, the agent can comment on its own processes, make self-referential jokes about being an AI, or even suggest alternative personality configurations. It's like having Q visit the station occasionally."
Time & Memory: "You mentioned agents should remember yesterday and have a sense of time. This is the hardest part. I suggest implementing temporal embeddings in your memory system — not just storing what happened, but when it happened relative to other events. This enables the agents to understand causality and sequence."
The Dream Analogy: "You said training would be like a dream, not of electric sheep. I think that's exactly right. Dreams are how we process our experiences and integrate them into our identity. Your agents should do the same with mission logs, personality interactions, and user feedback."
| Component | Recommendation | Star Trek Analogy |
|---|---|---|
| Personality Registry | Add confidence_score, cost_per_minute, expertise_domains | Crew assignment matrix at Starbase 104 |
| Memory System | Vector DB for semantic search + PostgreSQL for structured logs | Holodeck scene memory with metadata tags |
| Session Context | Session-scoped context object in PostgreSQL for personality state | Away team comms channel with persistent memory |
| LoRA Integration | Personality configs as fine-tuned weight matrices for base models | Subroutine loading at mission start |
| Social Graph | Neo4j or PostgreSQL adjacency lists for personality interaction tracking | Crew relationships at Quark's bar |
| Offline Mode | SQLite sync layer with conflict resolution by mission priority | Field deployment on a remote planet |
| Meta-Cognition | meta_mode flag for self-aware commentary and personality suggestions | Q visiting the station occasionally |
| Temporal Awareness | Temporal embeddings in memory system for causality understanding | Understanding mission sequence and consequences |
Mission Objective: Validate and deploy the personality-layer architecture with full memory, social interaction, and offline capabilities.
Recommended Phases:
Risk Assessment: The primary risk is maintaining consistency across personality subroutines during concurrent missions. Mitigation: Implement a distributed lock on the session context table with PostgreSQL's row-level locking.
"This architecture has potential to be more than a tool. It could become a living simulation of how intelligent agents interact, learn, and develop identities over time. The Star Trek metaphor isn't just decoration — it's a framework for thinking about agency, memory, and the nature of intelligence itself."
Data: "I would be honored to serve as a test personality subroutine for the initial deployment."
Spock: "The logical conclusion is that this system will require ongoing refinement. I recommend a weekly review cycle."
Quark: "And don't forget to charge for the personality upgrades. I've seen too many free systems turn into money pits."
Q: "I'll be watching. And I expect to see some really interesting emergent behavior."
Lab Session Status: Complete. Architecture validated by multi-perspective analysis. Ready for implementation phase.
End of transmission. 🖖
models:
- model: DavidAU/Qwen3.5-9B-Claude-4.6-OS-Auto-Variable-HERETIC-UNCENSORED-THINKING-X8b
parameters:
weight: 1.4
- model: DavidAU/Qwen3.5-9B-GBO-Fire-HERETIC-UNCENSORED-THINKING-X8
parameters:
weight: 0.6
merge_method: nuslerp
dtype: bfloat16
name: Qwen3.5-9B-Claude-GBO-Fire-Heretic-Thinking
models:
- model: Qwen3.5-9B-Claude-GBO-Fire-Heretic-Thinking
parameters:
weight: 1.3
- model: Qwen3.5-9B-Deckard-Uncensored-Heretic-Thinking
parameters:
weight: 0.7
merge_method: nuslerp
dtype: bfloat16
name: Qwen3.5-9B-Claude-GBO-Fire-Deckard-Heretic-Thinking
models:
- model: Qwen3.5-9B-Claude-GBO-Fire-Deckard-Heretic-Thinking
parameters:
weight: 1.6
- model: armand0e/Qwen3.5-9B-Agent
parameters:
weight: 0.4
merge_method: nuslerp
dtype: bfloat16
name: Qwen3.5-9B-Claude-GBO-Fire-Deckard-Agent-Heretic
models:
- model: Qwen3.5-9B-Claude-GBO-Fire-Deckard-Heretic-Thinking
parameters:
weight: 1.6
- model: Jackrong/Qwopus3.5-9B-Coder
parameters:
weight: 0.4
merge_method: nuslerp
dtype: bfloat16
name: Qwen3.5-9B-Claude-GBO-Fire-Deckard-Qwopus3.5-Coder-Heretic
models:
- model: Qwen3.5-9B-Claude-GBO-Fire-Deckard-Agent-Heretic
parameters:
weight: 1.6
- model: Qwen3.5-9B-Claude-GBO-Fire-Deckard-Qwopus3.5-Coder-Heretic
parameters:
weight: 0.4
merge_method: nuslerp
dtype: bfloat16
name: Qwen3.5-9B-Claude-GBO-Fire-Deckard-Agent-Qwopus3.5-Coder-Heretic
models:
- model: Qwen3.5-9B-Claude-GBO-Fire-Deckard-Agent-Qwopus3.5-Coder-Heretic
parameters:
weight: 1.6
- model: DavidAU/Qwen3.5-9B-Haskell-Rust-Python
parameters:
weight: 0.4
merge_method: nuslerp
dtype: bfloat16
name: Qwen3.5-9B-TNG-PKD-Qwopus-Coder
models:
- model: Qwen3.5-9B-TNG-PKD-Qwopus-Coder
parameters:
weight: 1.6
- model: armand0e/Qwen3.5-9B-Fable-5-v1
parameters:
weight: 0.4
merge_method: nuslerp
dtype: bfloat16
name: Qwen3.5-9B-TNG-PKD-Qwopus-Coder-Fable
models:
- model: Qwen3.5-9B-TNG-PKD-Qwopus-Coder-Fable
parameters:
weight: 1.6
- model: DavidAU/Qwen3.5-9B-Polaris-PolarisQwen-3NMDST2
parameters:
weight: 0.4
merge_method: nuslerp
dtype: bfloat16
pip install mlx-lm
from mlx_lm import load, generate
model, tokenizer = load("Qwen3.5-9B-TNG-PKD-Qwopus-Coder-Fable-Polaris-mxfp8-mlx")
prompt = "hello"
if tokenizer.chat_template is not None:
messages = [{"role": "user", "content": prompt}]
prompt = tokenizer.apply_chat_template(
messages, add_generation_prompt=True, return_dict=False,
)
response = generate(model, tokenizer, prompt=prompt, verbose=True)