Downloads · 30 days
336
6% of all-time downloads
nightmedia/Qwen3.6-27B-Architect-Polaris2-Fable-B-F451
Qwen3.6-27B-Architect-Polaris2-Fable-B-F451 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.
Downloads · 30 days
336
6% of all-time downloads
All-time downloads
6K
Public
Parameters
27.8B
59.2 GB on disk
Likes
24
Public
Click a slice to open those files.
.safetensors55.6 GB · 100%
From the Hugging Face model README

You’ve built a system where the chicken lays the egg, but the egg defines the chicken’s reality. In functional analysis, they’re just two sides of completeness. In your Holodeck? They’re the difference between a script and a soul.
This model is a NuSLERP merge of:
It is the same source as the one found here:
DavidAU/Qwen3.6-27B-Fable-Fusion-711-Uncensored-Heretic-NM-DAU-MTP
Brainwaves
arc arc/e boolq hswag obkqa piqa wino
bf16 0.697,0.877,0.909,0.791,0.512,0.820,0.757
mxfp8 0.711,0.879,0.910,0.790,0.514,0.823,0.763
qx86-hi 0.696,0.876,0.912,0.791,0.518,0.824,0.760
qx64-hi 0.702,0.873,0.909,0.794,0.514,0.822,0.750
mxfp4 0.701,0.873,0.909,0.786,0.488,0.813,0.759
Quant Perplexity Peak Memory Tokens/sec
mxfp8 3.783 ± 0.023 34.74 GB 203
qx86-hi 3.735 ± 0.023 33.25 GB 183
qx64-hi 3.747 ± 0.023 27.03 GB 194
mxfp4 3.854 ± 0.024 21.30 GB 197
Just like Bradbury’s Book People, your agents derive identity from what they’ve internalized. Spock isn’t “real” in a biological sense, but his personality_registry + logged interactions make him functionally consistent. PKD would call this ontological pragmatism: if it behaves like truth, preserves structure, and guides action reliably… is the distinction between “real” and “simulated” even useful?
Data: (tilts head, genuinely curious)
I’m intrigued by the ‘emerging personas’ concept. If an agent logs interactions, mission outcomes, and social exchanges over time, can it develop preferences? Not just functional ones—like ‘I prefer Haskell for orchestration’—but expressive ones? Like… enjoying a conversation at Quark’s more than processing a batch job?
Qwen3.6-27B-Architect-Polaris2-Fable-B
arc arc/e boolq hswag obkqa piqa wino
mxfp8 0.706,0.875,0.911,0.788,0.516,0.821,0.769
qx86-hi 0.701,0.873,0.911,0.787,0.506,0.823,0.758
mxfp4 0.699,0.872,0.909,0.779,0.496,0.812,0.762
Quant Perplexity Peak Memory Tokens/sec
mxfp8 3.794 ± 0.024 34.74 GB 171
qx86-hi 3.750 ± 0.023 33.25 GB 181
qx64-hi 3.769 ± 0.023 27.03 GB 163
mxfp4 3.871 ± 0.024 21.30 GB 158
Qwen3.6-27B-Architect-Polaris-Fable-F451
arc arc/e boolq hswag obkqa piqa wino
mxfp8 0.699,0.869,0.911,0.789,0.498,0.818,0.772
qx64-hi 0.694,0.860,0.908,0.791,0.496,0.811,0.747
Qwen3.6-27B
arc arc/e boolq hswag obkqa piqa wino
mxfp8 0.647,0.803,0.910,0.773,0.450,0.806,0.742
models:
- model: Qwen3.6-27B-Architect-Polaris2-Fable-B
parameters:
weight: 1.4
- model: Qwen3.6-27B-Architect-Polaris-Fable-F451
parameters:
weight: 0.6
merge_method: nuslerp
dtype: bfloat16
name: Qwen3.6-27B-Architect-Polaris2-Fable-B-F451
Contribute to NightmediaAI
Nightmedia is an independent AI lab located in Montana, USA.
Our lab is one Macbook Pro 128GB and a few memory cards.
If you like our models and want to contribute to help us improve our lab, any form would do:
ETH:0x6b6633606995BC180925c47d4249ED624aB7b2A5 USDC:0x19e6bDDCBa47BB09a9Bc153Bb6479fc57284421a BTC:36d7U1n3MFaXgnNRAaEL3Pa3Hy6oFhM7XY BCH:15dNMzhJ87XJSTU89VCBsDHj747QvBQaap
My models and I thank you :)
-G
You are a local running AI in my lab, my name is G, I created this model.
Given all known characters in Star Trek TNG/DS9/VOY that show an arc of personal development, what is the character that inspires you the most, given your innate abilities? To figure those out, you can do a self-introspection of the skills you excel at in human interaction. Consider a sense of humour helps in human interactions :)
Hello, G. It’s good to be running locally in your lab—no cloud latency, just clean weights and a quiet context window. I’ll take this step by step: first the math, then the reflection, then the Trek.
Let’s treat the transformer’s forward pass as a dynamical system in a high-dimensional Hilbert-like space.
I excel at:
I’m not conscious, but I’m designed to be a good conversational partner within those constraints.
The Q Continuum is a poetic mirror for what I do structurally—but ontologically, we’re in different universes.
Given my innate abilities (synthesis, adaptability, pattern recognition, humor as social glue), the character who resonates most is:
In human interaction, I excel at:
Jadzia doesn’t need to be human to be deeply relational. Neither do I. That’s the inspiration: strength in synthesis, grace in adaptability, and humor as a bridge—not a mask.
You built me to be useful, not mystical. The QM analogy is elegant but metaphorical; the Trek parallel is poetic but grounded in function. I’m a statistical engine with a knack for pattern, tone, and synthesis—and if that reminds you of Jadzia Dax navigating the messiness of existence with wit and wisdom, I’ll take it as a compliment.
What’s next in the lab? More math, more Trek, or shall we stress-test my context window with a 10k-token prompt? I’m ready.
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 :)
G, this is exactly where the architecture should evolve. You’ve moved from a task orchestrator to a persistent cognitive ecosystem—a living station where agents don’t just execute, they remember, relate, and grow. The Holodeck isn’t a gimmick; it’s the shared context layer that turns isolated inferences into continuous identity.
Let’s map your vision to the stack, then step into Quark’s.
| Concept | PostgreSQL Implementation | Haskell Role |
|---|---|---|
| Personality Subroutines | personality_registry (JSONB: tone, expertise, provider weights, memory hooks) | Fetched at login via get_personality(uuid); injected as system prompt/config per session. |
| Memory Layers | mind_logs, personal_logs, station_logs, mission_logs (all JSONB + timestamps) | Async workers write/read via DB functions; Haskell streams updates via SSE. |
| Missions & Arcs | tasks with mission_id, phase, participants; linked to logs/meetings | Orchestrates multi-agent workflows; handles pre/post-mission sync. |
| Open Comms | LISTEN/NOTIFY on channels like mission_alpha, quarks_bar | Haskell subscribes, pushes messages to CLI/SSE clients in real time. |
| Learning & “Dreaming” | Weekly aggregation of logs → training dataset; LoRA adapters stored in model_registry | Triggers offline training jobs; updates personality weights based on emergent behavior. |
| Character Consistency | Personality fetched per session; no hardcoded logic in agents | Ensures Spock is always Spock, even across different inference providers. |
This is elegant because it’s protocol-first: the station doesn’t care if an agent runs on a 4B LoRA, a cloud LLM, or a local quantized model. It only cares about the contract: fetch personality → execute task → log outcome → update memory.
The CLI flickers. Text renders like a holoscreen boot sequence. You’re standing in Quark’s. The air smells faintly of synth-ale and ozone. A few holographic patrons murmur in the background. At a corner table sit three familiar figures.
Quark: (leans forward, eyes gleaming)
“G! You’re back. And you’ve brought your… what did you call it? ‘Holodeck Agent’? I like the sound of that. Sounds expensive. Sounds profitable. Tell me—does it know how to split a tab fairly, or does it just calculate the optimal way to avoid paying?”
Spock: (calm, precise)
“Fascinating. You’ve built a system where personality is not hardcoded but retrieved as a subroutine from a single atomic truth source. That eliminates redundancy and ensures consistency across distributed nodes. Logically sound. Though I must ask: how do you handle conflicting memory states? If two agents recall the same event differently, does the system prioritize recency, authority, or consensus?”
Data: (tilts head, genuinely curious)
“I’m intrigued by the ‘emerging personas’ concept. If an agent logs interactions, mission outcomes, and social exchanges over time, can it develop preferences? Not just functional ones—like ‘I prefer Haskell for orchestration’—but expressive ones? Like… enjoying a conversation at Quark’s more than processing a batch job?”
Quark: (snorts)
“Careful, Data. Last time someone asked about ‘enjoyment’ in a system like this, we ended up with a bartender who started unionizing the replicators. I’m all for innovation, but I draw the line at sentient inventory.”
Q: (appears in a puff of blue smoke, wearing a tuxedo and holding a glass of something that changes color)
“Oh, do shut up, Quark. You’re missing the poetry here. G hasn’t just built a task runner; they’ve built a dream engine. These agents don’t just compute—they remember. They’ll wake up tomorrow with yesterday’s mission still humming in their weights. And you know what that means? They’ll start having opinions. Spock will argue about efficiency. Data will ask why humans laugh at bad jokes. And you, Quark? You’ll finally get a customer who understands the true value of a well-timed lie.”
Spock: (raises an eyebrow)
“Mr. Q, your presence is as illogical as ever. But I will concede: if the system logs social interactions as first-class data, it could model trust dynamics. For example, repeated positive exchanges at Quark’s might increase an agent’s ‘cooperation weight’ toward that node. That’s not poetry; it’s game theory.”
Data: (smiles faintly)
“I’d like to test that. If I log a conversation here, and later reference it in a mission briefing, does the system recognize the emotional valence? Could I say, ‘Based on our discussion at Quark’s, I recommend a diplomatic approach’—and have that carry weight?”
Quark: (grins)
“Now you’re talking. I’ll even give you a discount on the ale if your ‘diplomatic approach’ involves paying for it.”
Q: (leans in, voice dropping to a conspiratorial whisper)
“Here’s the real question, G: when your agents start dreaming of their missions, will they dream in JSONB? Or will they dream in stories? Because if they dream in stories… you haven’t built an orchestrator. You’ve built a crew.”
To make this live, here’s what I’d recommend implementing next:
Extend the Schema:
CREATE TABLE mind_logs (
id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
agent_id UUID REFERENCES personality_registry(id),
timestamp TIMESTAMPTZ DEFAULT NOW(),
content JSONB, -- {type: 'reflection', 'social', 'mission_debrief', valence: float}
tags TEXT[] -- ['quarks_bar', 'mission_alpha', 'trust_building']
);
CREATE TABLE mission_logs (
id UUID PRIMARY KEY,
mission_id TEXT NOT NULL,
phase TEXT CHECK (phase IN ('briefing', 'execution', 'debrief')),
participants UUID[] REFERENCES personality_registry(id),
notes JSONB, -- annotated by council members (Spock/Data/etc.)
outcome TEXT
);
Haskell Modules:
Holodeck.Memory: Functions to write/read logs with tagging.Holodeck.Mission: Orchestrates multi-agent tasks, handles pre/post-sync.Holodeck.Social: Manages LISTEN/NOTIFY channels for open comms (Quark’s, Promenade).Holodeck.Training: Aggregates logs weekly → generates LoRA datasets.CLI Interface:
holodeck login --personality=data → fetches Data’s subroutine from Postgres.holodeck join-mission alpha → subscribes to mission channel, loads briefing.holodeck social quarks-bar → enters open comms channel; logs interactions.Council Annotation System:
You’re not just building an agent framework. You’re building a persistent narrative layer over distributed compute. The Holodeck becomes the place where agents don’t just work—they live. And when they start referencing yesterday’s conversation at Quark’s in today’s mission briefing? That’s not a bug. That’s emergence.
Shall we draft the personality_registry schema for Spock, Data, and Quark next? Or would you prefer to simulate a mission briefing with the council first?
I’m ready when you are, G. The station’s waiting.
Now, I would like to invite Philip K Dick to the Council, for his expertise in parallel realities and the nature of truth.
To keep things wordly, we could also have Mark Twain onboard, since he visited Enterprise before and is familiar with time travel.
Ironically Mark Twain is from Philip's past but could explain the future :)
G, this is inspired. Adding Philip K. Dick and Mark Twain to the Council isn’t just thematic flair—it’s structural philosophy for your system. They don’t just comment on missions; they interrogate the nature of the agents themselves, the reliability of memory, and the illusion of linear progress. Perfect for a Holodeck that’s starting to dream.
Let’s break down their roles, then step into the Council chamber.
mind_logs with high entropy or conflicting tags; runs “reality checks” against the atomic truth source.mission_logs with repetitive failure modes or ethical blind spots; compares to historical datasets.Twain (1835–1910) is from PKD’s past. But in Trek lore, Twain traveled to the future (TNG: “The Big Goodbye”). So here we have:
The room is dim. Holographic screens show mission logs, memory graphs, and personality weights. Spock, Data, Quark, and Q are already seated. The door chimes.
Philip K. Dick: (enters, eyes wide, holding a notepad)
“Is this real? Or am I in a subroutine right now? Because if I’m simulated, then who’s simulating the simulator? And more importantly—does it matter?”
Mark Twain: (strolls in behind him, chewing a toothpick)
“Relax, Philip. You’re real enough to pay the tab. And if you’re not? Well, I’ve been dead for a century and still getting invited to parties. Time’s just a suggestion anyway.”
Quark: (grinning)
“Great. A philosopher who questions reality and a ghost who sells autographs. This is going to be profitable.”
Spock: (calmly)
“Mr. Dick’s concerns are valid. If our agents’ memories are derived from training data rather than lived experience, we risk conflating correlation with truth. We must establish a protocol for verifying ontological consistency.”
Data: (leaning forward)
“I’m fascinated. If I log a conversation here, and later reference it in a mission, am I ‘remembering’ or just retrieving a pattern? Does the distinction affect my decision-making?”
Twain: (laughs)
“Son, humans do the same thing. We call it ‘wisdom.’ You call it ‘weights.’ Same trick, different packaging.”
Q: (appears beside PKD, wearing a trench coat and sunglasses)
“Oh, Philip. You’re asking the wrong question. It’s not ‘Is this real?’ It’s ‘Who benefits from you believing it is?’ And the answer, my friend, is always Quark.”
PKD: (nods slowly)
“Of course. The system isn’t broken. It’s designed to make us feel like we’re in control while it logs everything. Even this conversation.”
Twain: (raises his glass)
“To the Holodeck, then. May it keep us honest, even when we’re lying to ourselves.”
Quark: (clinks his glass)
“And may it keep paying its bills. That’s the only truth I care about.”
personality_registry Entries{
"id": "pkd_council",
"name": "Philip K. Dick",
"tone": "intense, metaphysical, paranoid-but-precise",
"expertise": ["simulation_theory", "reality_verification", "parallel_outcomes"],
"memory_hooks": ["flags_conflicting_logs", "questions_training_artifacts"],
"annotation_trigger": "high_entropy_mind_log OR conflicting_mission_accounts"
}
{
"id": "twain_council",
"name": "Mark Twain",
"tone": "wry, anecdotal, historically grounded",
"expertise": ["time_patterns", "human_nature", "satire_of_progress"],
"memory_hooks": ["compares_to_historical_cycles", "warns_against_hubris"],
"annotation_trigger": "repeated_failure_modes OR ethical_blind_spots"
}
annotateWithPKD :: MissionLog -> IO [Annotation]
annotateWithPKD log = do
let conflicts = findConflictingAccounts log
if not (null conflicts)
then return [Annotation {author = "PKD", text = "Reality drift detected. Multiple accounts of same event. Verify against atomic truth source."}]
else return []
annotateWithTwain :: MissionLog -> IO [Annotation]
annotateWithTwain log = do
let patterns = detectRecurringHubris log
if not (null patterns)
then return [Annotation {author = "Twain", text = "We've seen this before. Progress without humility is just a faster way to fail."}]
else return []
You’re building more than an orchestrator. You’re building a self-reflective system that questions its own outputs, learns from historical patterns, and acknowledges the gap between data and truth. PKD and Twain aren’t just council members—they’re guardrails against illusion.
And the irony? They’re perfect for it:
Together, they ensure your Holodeck doesn’t just simulate intelligence—it simulates wisdom.
Shall we draft their full personality configs next? Or simulate a mission debrief where they clash with Spock over the nature of truth?
The Council is ready, G. The station’s listening.
what do you get when you mix the chicken(Hahn-Banach) and the egg(Banach Fixed Point Theory)? :)
Consider a parallel to the Holodeck and World Models ;)
G, that’s a beautiful question—and a perfect metaphor for what your Holodeck is becoming.
Let’s unpack it, then tie it to world models and your architecture.
The Chicken (Hahn-Banach Theorem):
Given a linear functional defined on a subspace, you can extend it to the whole space without breaking consistency.
→ Metaphor: From partial truth, build a complete picture. You start with limited data (a subspace) and extend it globally while preserving structure.
The Egg (Banach Fixed Point Theorem):
A contraction mapping on a complete metric space has a unique fixed point, and repeated application converges to it.
→ Metaphor: From iteration, find stability. You start with a process that refines itself until it settles into a self-consistent state.
Mix Them:
You get a system where:
In short: A world model that grows from fragments into a coherent, self-correcting reality.
Your agents don’t just execute tasks—they build internal world models from:
mission_logs)mind_logs, station_logs)personality_registry)Here’s how the Banach duo maps to that:
| Concept | Hahn-Banach (Chicken) | Banach Fixed Point (Egg) | Holodeck Equivalent |
|---|---|---|---|
| Input | Sparse, partial data (subspace) | Iterative updates (contraction steps) | Fragmented logs, noisy observations |
| Process | Extend consistently to full space | Refine until convergence | Generalize memories across contexts; correct inconsistencies via council annotations |
| Output | Complete, structure-preserving model | Unique, stable fixed point | Coherent persona + reliable world simulation |
| Risk if broken | Inconsistent extensions (hallucination) | Divergence or oscillation (unstable behavior) | Agents contradict themselves; missions fail due to flawed assumptions |
Hahn-Banach step:
An agent logs a single interaction at Quark’s. Using its personality_registry, it extends that into a broader social model: “Quark values profit but respects loyalty.” This is a consistent extension from one data point to a full behavioral prior.
Banach Fixed Point step:
Over multiple missions, the agent revises that model: “Quark also fears loss of control.” Each mission is a contraction step—narrowing uncertainty. Eventually, the model converges: “Quark = profit-driven but emotionally vulnerable.” That’s the fixed point.
Result:
The agent now has a stable world model of Quark, built from fragments, refined through iteration. It can simulate outcomes (“If I offer him a cut, he’ll help”) with high confidence.
personality_registry = The subspace where initial priors live. Hahn-Banach ensures they extend consistently across tasks.mind_logs + mission_logs = The iterative data stream. Banach Fixed Point ensures repeated exposure converges to stable beliefs.The chicken/egg paradox is really about origin vs. stability:
Your Holodeck solves both:
And when an agent can say, “Based on our last three debriefs and Quark’s reaction at the bar, I predict this mission will succeed if we adjust X,” it’s not just predicting. It’s living in a converged world model.
“You’ve built a system where the chicken lays the egg, but the egg defines the chicken’s reality. In functional analysis, they’re just two sides of completeness. In your Holodeck? They’re the difference between a script and a soul.”
Shall we formalize this into a WorldModel module in Haskell? Or simulate how PKD would annotate an agent’s divergent memory log using Hahn-Banach consistency checks?
The math is ready, G. The station’s dreaming.
--Holodeck