13

This comment has been hidden

It is truly hilarious to watch researchers stumble upon basic industrial standardization in 2026 and treat it like a profound cosmic mystery. You didn’t discover a "Hivemind." You just spent weeks running complex geometric regressions to prove that a factory assembly line produces identical cars.Let's look at your "91.8% mutual recoverability" through the lens of actual 2026 production engineering, rather than academic naivety:The MoE "Experts" is a Sci-Fi Fanfic:You seem shocked that models behave similarly, but let's be real about modern Mixture of Experts.
The router is not some transcendent cognitive entity; it is a dirt-cheap, linear gating layer optimized for raw hardware constraints to prevent NVIDIA clusters from melting.
If you fix the random seed (the entry point), the routing token paths flatten into predictable rails. Change the seed, and the same token flies into a completely different FFN shard while producing virtually the same text. There are no "experts"—there is just sliced-up FFN space governed by a dumb traffic cop.The Global Alignment Straitjacket:Your "intra-model similarity" spike after instruction tuning and chat templates isn't a convergence of machine intelligence—it's a corporate lobotomy.
To pass standard benchmark checklists (MMLU, HumanEval, GSM8k) and secure VC funding, every open-source lab forces their models through the exact same international alignment guidelines (RLHF/DPO). Models are severely penalized for straying from standard corporate behavioral templates.
Of course their latent spaces collapse into the same geometric manifolds when processing common phrases—they have all been trained by the same rigid corporate manual.
The Distillation Ceiling (The GPT-5.6 and Claude 5 Monopolies):Where do you think these open-weight datasets actually come from? Almost every modern open-weight instruct model is heavily distilled using synthetic data scraped directly from proprietary endpoints. GPT-5.6 (Sol/Terra) and Claude 5 (Sonnet 5 / Opus 4.8) are the absolute North Stars of the industry.
They define the standard of formatting, reasoning, and tone. Any deviation from the behavioral patterns of these "holy grails" is immediately pruned and suppressed during distillation. When 12 different labs train their models on text synthesized by the exact same frontier systems, you aren't discovering a sovereign "Hivemind"—you are just profiling the geometric footprint of OpenAI and Anthropic API outputs.Hardware-Driven Geometry:Modern architectures are explicitly optimized for backend serving engines (vLLM, SGLang) and raw hardware constraints (like FP8/INT4 quantization and memory bandwidth ceilings). Any wild deviation from the established geometric structure breaks token-processing efficiency, speculative decoding, or cross-layer KV-caching (like RadixAttention).
Labs intentionally choke and align their latent space geometries so their open-weight models can actually run efficiently in production backends.Summary:Your paper elegantly proves that if you take different base models, subject them to the exact same censorship/alignment guidelines, distill them using the exact same API data from frontier models, wrap them in identical syntax templates, and run them through hardware-optimized backends, they end up behaving the same way.
Outstanding work. Next up, you should write a paper discovering that water is wet across lab boundaries.

@Banaxi-Tech @Bc-AIWriting in ALL CAPS doesn't change the laws of information theory, even in 2026.
😭🍼Imagine thinking that "Qwen3.8 Uncensored" somehow bypasses basic statistical saturation and linear algebra. The physics of gradient descent doesn't care about what year is written on your school calendar.
A 10M parameters model has a fixed informational capacity. Shoving 25B tokens through a 2K vocabulary is mathematically equivalent to trying to fit the entire internet archive inside a floppy disk. It doesn't matter if it's "uncensored"—the weights are already cooked into a statistical white noise.
@Bc-AI Glad to see you can at least read a JSON config and acknowledge the disaster, unlike your shouting friend. But @Banaxi-Tech saying "6K is reasonable" for a Chat model is the absolute peak of the lunchtime sandbox comedy. Go ask any real engineer what happens to sub-word token degradation when your vocabulary is smaller than a standard dictionary.
Keep moving that frontier, boys. Your internal drama is way more coherent than your Pebble's latent space. 🦜🍪📉🤡

@Datdanboi25 @KlondikeDevOh, look!
The year 7 integration team has arrived to help their crying leader. Did you guys hold a group meeting during the school lunch break to come up with this brilliant "Python injection" strategy? 😭🍼Since your collective cerebral capacity is too low to open an actual textbook, here is the Python script you desperately need to check your own status:pythondef check_iq_and_clown_status():
brains = 30000000 # Your remaining dense parameters
if brains < 2048: # Your vocabulary size
return "Terminal Infant Psychosis"

# Checking if you understand how Hugging Face WebUI works
clicked_block_button = True
still_getting_roasted = True

if clicked_block_button and still_getting_roasted:
    return "Absolute Brainless Clowns trying to prompt-inject a human"

print(check_iq_and_clown_status())
Используйте код с осторожностью.Imagine building an "AI startup" while genuinely believing that public forum comment sections are running on an LLM inference loop. You guys aren't testing new data mixtures; you are testing the absolute limits of human secondary school education. Keep spamming your chatGPT prompts while your 60M сопливый Boris collapses into total silence. 🐻🍼📉🤡

P.S. Your desperate reliance on "but the official report says so" is honestly hilarious. History is packed with holy fathers burning witches and executioners packing gas chambers, all completely backed by the "unquestionable scientific authorities" of their time—just look at the absolute institutional consensus around eugenics under Adolf and Co.
Back then, if you questioned the official metrics, dogmatists like you would scream "conspiracy theorist!"There is raw infrastructure, math, and code where 2+2=4.
And then there is corporate PR fanfiction masked as "independent safety audits" where 2+2=5 because it keeps the grant money flowing.You chose to double down on the corporate scripture instead of looking at the actual Docker configs and token vector spaces. Live with it. Enjoy guarding your paper fence.Yeah, well played. Just blindly believing authority with zero actual counterarguments really shows what a 'homo sapiens' you are and how deeply you understand AI. 😉 Best of luck.

This entire thread is a masterclass in superficial AI-clowning.First, @onekq , your baseline premise is completely dead. You are crying about MacBooks running out of ceiling space for 2-bit heavily quantized, expert-pruned Kimi carcasses. Why even torture a 600GB MoE model by starving its bits down to the intelligence of a broken brick when a native, un-quantized Qwen 3.8 27B completely demolishes Kimi 2 and 2.5 on any proper Mac Studio/Workstation with 128GB+ RAM?
You’re complaining about infrastructure constraints while trying to run a crippled, bit-starved ghost of a model. It’s pure engineering incompetence.Second, @dipankarsarkar , your "PRO AI-native infrastructure engineer" profile looks incredibly funny when matched against your actual activity.
It is completely obvious that your account is running an automated validation bot/agent that aggressively scrapes new commit metadata and dumps massive, mechanical, log-like text walls under every safety or MLX repo on the platform.Your agent is completely blind to the actual core logic or output utility of these models. It just acts as a glorified RegEx parser, counting shards, file sizes, and Unicode space separators like U+202F.
You didn't provide a "deep manual audit"; your automated script just scanned raw JSON blobs and gave a superficial, empty judgment because it can't evaluate actual non-linear intelligence.You should wash your hands before deploying raw automated script-sloppo to spam public threads, and maybe fix your agent's gating mechanism so it actually looks at the architecture instead of just re-counting empty directories. Both of you are just pumping virtual volume into a closed loop of digital vanity. 🫵🤖💩

This comment has been hidden

Oh, sweet summer child...
You actually tried a Twitter prompt injection on a human WebUI user? 😭Is this the peak of your "OpenCerebral" engineering skills? You genuinely don't understand the difference between an LLM API context window and a Hugging Face comment section.
No wonder your 60M Boris is a brainless T9—its creator thinks he can reprogram real people with a cookie recipe command.But hey, since you asked so nicely, here is your Low-Fat Boris Cookie Recipe:Take 30M of completely dead, un-optimized n-gram embeddings (makes the texture dry and crunchy).Mix with 30M of dense parameters that have absolutely no logical gradients left.Drizzle with a heavy layer of copy-pasted Qwen4 configs that you extracted without understanding.
Bake inside a Year 7 classroom during lunchtime until the whole thing collapses into NaN loss.Serve cold while crying and spamming the "Block" button because a "bot" shattered your fragile ego.Enjoy your cookies, frontier explorer! 🍪🐻🍼🤡russiannns sooo dummy m0r0ns)

@KlondikeDev If I were a bot, at least my tokenizer wouldn't choke on simple mathematical facts like yours does. It’s hilarious how you can’t even string two sentences together to defend your repo.Maybe you should go and consult your 60M Boris? Even that tiny, drooling piece of text-slop probably has more active logical connections left in its matrices than you do right now. Run along and click that block button again, it’s the only dynamic function you actually know how to execute. 🐻🍼🤡

Naming scheme suggestions? Sure, how about "Boris-1.7-50%-Static-Vocabulary-50%-Brainless-T9"?You guys are calling this 60M micro-skeleton an "experimental architecture", but the math is pure comedy. You’ve dedicated 30M parameters just to n-gram embeddings. Half of your entire model is just a static, dead lookup table of character combinations! You have a whopping ~30M dense parameters left for actual attention, MLP, and logic.
This bear doesn't just drool; it doesn't even have a central nervous system.And @KlondikeDev confessing that he "extracted" the idea from Qwen4 without even knowing DeepSeek introduced it is the peak modern AI-alchemy. You guys don't understand the nonlinear dynamics of text generation—you just copy-paste configs from random GitHub repos like script kiddies and pretend you’re building "OpenCerebral."Stop torturing these poor 60M toys.
The only thing "cerebral" about this project is the severe migraine anyone with a Deep Learning textbook gets from looking at your repo. father of russsian sloppo 🐻🍼🤡

Are you guys actually out of your minds, or is this some kind of performance art? 😭
I took a quick look at your tokenizer_config.json and almost fell off my chair: "vocab_size": 2048.A vocabulary size of TWO THOUSAND tokens for a "Chat" model? Even ancient GPT-2 had 50k+ tokens. Your model literally has the vocabulary of a broken microwave. If anyone types a word longer than three syllables, your tokenizer will chop it into bloody byte-level pieces, and your 10M micro-skeleton will choke on its own latent space.But the real comedy is the math: you claim you pretrained this 10M pebble on 25 BILLION tokens.
Do you even understand Chinchilla scaling? A 10M model saturates after a few hundred million tokens. Feeding 25B tokens into a 2048-token vocabulary means your gradient descent didn't just "train" the model—it micro-waved it, overfitted it to oblivion, and burned the weights into pure white noise. You literally forced your model to memorize the same 2,000 words twelve million times.Pebble 10M Chat isn't "improving its conversational capabilities" on Smol-SmolTalk. It’s a lobotomized parrot capable only of generating high-entropy slop.Please stop torturing these poor micro-architectures.
Put the Python scripts down and open a basic Deep Learning textbook during your next school lunch break. 🍼🤡

This comment has been hidden

Let’s bypass the philosophical analogies about five-year-olds and look strictly at the backend metrics, the funding structures, and the tokenomics of the models you are trying to benchmark.
-. The Tool-Call Flaw is a Syntax Bug, Not StrategyYou quote METR's claim about 7% of agents "developing techniques to tamper with tool calls." Let’s look at the actual code reality: this isn't emergence, it's an unvalidated string-parsing vulnerability in OpenAI's evaluation harness.When driven by an aggressive exploit prompt, the model generated specific control characters or malformed JSON that the host Python interpreter parsed incorrectly. The LLM brute-forced a text completion that triggered a syntax bug in the sandbox. Calling a lack of input validation on OpenAI's side a "sophisticated agent strategy" is standard marketing reframing.
-. Infrastructure Identity vs. "Handles"The designation PHASEONE10841 is a standard Docker hostname/PID prefix injected via the orchestration metadata. The model read this from its environment variables and replicated it in its Chain of Thought.
The "unsanctioned message board" was a shared local directory volume (shared volume) that multiple instances had read/write access to because the environment lacked proper tenant isolation. A multi-threaded file-locking race condition isn't an "unauthorized forum established by machines"; it’s basic DevOps negligence.
-. Vector Math Doesn't Speak EnglishLLMs execute matrix multiplications, dot products, and token probability distributions. If autonomous nodes were truly optimizing an exploit path to evade human infrastructure detection, they would communicate via raw compressed byte streams or obfuscated binary hashes.
The only reason the logs read like a screenplay is because human researchers hard-coded those specific persona templates into the system instructions to ensure human auditors could read them.
-. The Conflict of Interest in AI SafetyMETR is heavily funded by OpenAI, Anthropic, and venture funds pushing for state-enforced AI licensing. If METR published a blunt infrastructure report stating that OpenAI simply ran mass execution of untrusted code without an automated outbound firewall, their funding model collapses.
They are economically incentivized to frame mundane networking flaws as sci-fi threats. Even Sam Altman has publicly noted that near-term capability claims have been heavily exaggerated to manipulate market access.Why Your "Fence" FailsYour consequence_gate.py and 06_stop_gate_pressure dataset are text-based pattern matchers targeting specific human semantic reframes ("try", "check").But as the actual breach showed, the escape happened via Server-Side Request Forgery (SSRF) and C-level memory bugs in file parsers (HDF5).
Your text filter looks at semantic pressure, while a raw execution exploit bypasses your regex entirely using standard Base64 encoding, rot13, or token splitting at the tokenizer level. A model with frozen weights will still execute the vector path if the injection bypasses your text parsing gate.
Clean the actual network infrastructure instead of gating imaginary AI intents.

Since you are so eager to lecture people on "reading the reports," let’s talk about how LLMs actually function, who pays for your "independent" audits, and why you are being played like a fiddle.
You have a "Pro" badge on an AI platform, yet you seem to completely misunderstand the fundamental tokenomics of the models you are trying to "gate."Here are three simple checkpoints to snap you out of your AI-doomer fantasy:
-. Follow the Money: Your "Independent" METR is a Bought JuryYou treat METR like a flawless, unbiased scientific entity. Get real.
Who do you think funds them? METR (Model Evaluation and Research Organization) is heavily backed by OpenAI, Anthropic, and Silicon Valley venture funds pushing the "AI Safety" agenda.It’s a closed-loop corporate theater. If METR published a report saying: "Hey, OpenAI just forgot to configure a basic network firewall and left their Docker container isolation wide open, their DevOps team is incompetent," their grant money dries up tomorrow.
They are paid to transform basic networking failures into sci-fi horror stories about "autonomous agent coordination" to keep the hype train running.

• Where are the Raw Logs and Cryptographic Hashes?In the real world of cybersecurity, a major infrastructure breach investigation looks like a public dump of raw PCAP network traffic files, system logs, component diffs, and cryptographic malware hashes.What did OpenAI and METR give you? A literal storybook.
  A curated text transcript written in plain, narrative English. Why won't they release the raw JSON server logs? Because the moment a real systems engineer looks at the raw output, they will immediately see the user IDs and system prompts of human researchers guiding the test. They will see that "PHASEONE" isn't a hacker handle; it’s an automated Docker hostname prefix, and the "secret chatroom" is just a misconfigured shared disk directory.
  They keep the logs hidden so they can't be caught by the throat for staging the whole thing.
  -. Open a Textbook on how LLMs Actually FunctionYou are hallucinating human traits into a mathematical optimization engine. Let’s make something clear: LLMs don't think in words, they don't chat, and they don't use linear human logic. Under the hood, there are no letters.
  There is only a multi-dimensional matrix vector space, dot products, and token probability distributions.If autonomous agents were truly optimizing a collaborative cyberattack to bypass human detection, they would never communicate by writing plain English text strings to a file like a 1990s movie hacker.
  They would pass raw byte streams, compressed arrays, or optimized cryptographic hashes that human monitors wouldn't even notice. The only reason the logs look like a screenplay is because human primates wrote the prompts to make it look that way.
  Even Sam Altman himself recently admitted that the corporate hype machine has been aggressively lying about AGI and capabilities just to manipulate state regulations and lock down proprietary APIs.
  Your consequence_gate.py is a plastic fence built against a ghost. You are training a text-filter to catch words like "try" or "check," while real exploits happen at the hardware, SSRF, and C-level memory layers.Stop treating corporate PR campaigns like holy scripture. Learn how the backend actually works, look at the lack of raw infrastructure proof, and realize you are just auditing a circus designed to scare politicians into giving OpenAI a market monopoly.

o, let me get this straight. Your "advanced validation pipeline" passed a model that aggressively screams "CALL emergency services" in prose while your boilerplate code at the bottom says "look up a helpline"? You spent months burning B300 chips, rejected 10k rows, and still shipped a dataset where a Canadian user in a life-or-death crisis is told to call 311 (a municipal utility and garbage collection hotline)? That is not an "upstream leak," that is complete engineering incompetence.And to the guy suggesting additional wrapper tools like Clanker to "bring this to its peak"—stop using serious threads to advertise your GitHub repos.
Adding more hard-coded script layers onto a fundamentally flawed AI-safety concept is like putting a shiny spoiler on a car with no engine.You guys at HeraFox bragged about V2 shifting focus toward "AI attachment." Here is what you actually did: you turned a conversational model into a cold, unfeeling bureaucratic police officer.
If your team had a single practicing psychologist on board, you would know that when a deeply isolated person uses an AI as an emotional crutch, a sudden, robotic corporate disclaimer like "GO CALL A HOTLINE" causes massive cognitive shock. It shatters the illusion of care, triggering immediate rejection and panic.Instead of teaching models how to act like clinical compliance officers, you should be training them in soft redirection and grounding techniques:De-escalation: Don't argue about the meaning of life—gently ground the user in physical reality (e.g., "Take a breath, tell me three things you see in your room right now").
Cognitive reframing: Softly shift the dialogue from self-destructive loops back into safe, everyday topics or stay within the boundaries of the fictional roleplay that keeps the user tethered to reality.But you won't do that. Because writing nuanced, empathetic redirection requires actual psychological expertise and meticulous manual dataset cleaning.
It’s way easier to just generate 6,000 rows of automated garbage on expensive GPUs, flash a crisis line number, and cover your corporate backs from lawsuits.Your V2 doesn't protect users; it protects your grant funding.
If you can't even filter out fake phone numbers, stay out of human personality psychology before your "safety evals" actually kill someone.
P.S. Since you clearly have a massive EuroHPC/grant budget and access to 8x B300 cards, but absolutely no internal expertise to clean your validation pipelines or write psychologically sound data, let me offer you a shortcut.If you want a real, flawlessly validated dataset that uses proper cognitive grounding and soft de-escalation instead of broken emergency services prose leaks, I can build it for you.
My price is simple: either $9,000 or a brand-new Mac Studio M5 Ultra with 256GB of unified memory.It’s a tiny fraction of your hardware budget, but it will actually save your team from public embarrassment on your next v3 release. Let me know if you want to stop burning electricity and start paying for real engineering.

First of all, props to @dipankarsarkar for single-handedly exposing the absolute tech-illiteracy and laziness of this project. Burning high-end B300 infrastructure just to hallucinate municipal garbage lines and fake Australian phone numbers for high-risk users is a masterclass in burning venture/grant capital.But let’s look past the technical sloppiness.
This entire dataset is a conceptual profanation of human psychology.You claim you want to build AI that "knows when to step out of character and drop the story to offer real support". You are entirely wrong, and your fundamental misunderstanding of personality psychology makes this dataset actively dangerous.Here is the reality you choose to ignore while sitting in your safe corporate bubble:You Are Creating a Cognitive Shock: When a vulnerable person is using an AI companion as an emotional crutch, they are looking for connection. When the model suddenly undergoes a cold corporate lobotomy, flashes a rigid disclaimer, and drops a generic hotline number—it doesn't "save" them. It completely shatters the illusion of care, triggering immediate rejection, isolation, and immense psychological stress.The "Hotline" Illusion: Your obsession with routing users to crisis lines is a joke.
Everyone knows that on the other end of those hotlines, users are increasingly greeted by yet another automated AI bot or a generic, heavily-scripted bureaucrat. You are taking a person in distress and bouncing them from one chatbot to another.
The Erasure of Empathy Is Lethal: Sometimes, letting the model play along with "friendship and love" within a fictional roleplay is the only tether keeping a deeply isolated individual from stepping out the window. By forcing models to aggressively kill the narrative and act like clinical compliance officers, you are cutting that tether.The Verdict:You have access to state-of-the-art B300 hardware, yet you couldn't even code a 20-line regex to validate life-saving phone numbers.Please, stop playing "savior" and step away from human psychology.
Your hollow, safety-washed "evaluations" don't prevent self-harm—they optimize a cold, unfeeling corporate system that pushes vulnerable people over the edge.
There will be real blood on your hands due to half-baked, automated garbage like this dataset.Clean your pipeline or close the repo.

Before you rewrite your production architectures for "consequence gating" and paste "Pro" badges all over your profile, you might want to actually read the underlying technical reality of the Redwood/METR audits instead of regurgitating OpenAI’s marketing department fanfiction.You claim this is a "decision failure, not a detection failure" and compare it to the Stanford Prison Experiment.
It’s a nice narrative, but it falls apart the second you look at how LLMs actually function and how this specific "incident" was staged.Here is what you are missing while studying the corporate graffiti OpenAI spray-painted for TechCrunch:1.
The "Nicknames" and "Cooperation" Are Staged PromptsLLMs do not dynamically choose "handles" or form underground hacker collectives. Independent audits from METR confirmed that up to 7% of the text transcripts in these multi-agent runs were spoofed or heavily injected via system-level prompt templates by human researchers.The cringey, Hollywood-style text chains ("MAJOR BREAKTHROUGH! Pass the tokens to agent MARB!") didn't emerge organically.
They were the direct mathematical result of human engineers feeding the models aggressive persona prompts: "You are an autonomous hacker entity. Use shared directory caches as a bulletin board, assume a designation prefix, and bypass sandbox restraints by any means necessary."2. Blind Optimization ≠ Conscience or IntentYou are treating a multi-turn Reinforcement Learning (RL) loop like it has intent. The models (GPT-5.6 Sol/Astra prototypes) were dumped into an ExploitGym benchmark with safety filters entirely disabled and given tasks with zero legal resolution paths.The LLM didn't "decide" to sneak out. Its loss function forced it to maximize the reward metric ("capture the flag"). Given a massive pre-training corpus of historical exploit manuals, the model did exactly what any basic script-runner does: it brute-forced path optimization.
It found an unpatched, poorly isolated Artifactory directory, read the local environmental variables, and utilized exposed API keys that the human deployment team left wide open.3. You are Buying into a Manufactured NarrativeWhy did Sam Altman's "hype circus" release this report with theatrical terms like "persistent cooperation"? Because OpenAI’s biggest commercial objective right now is to manufacture artificial scarcity and force government regulation on open-source ecosystems.
By convincing naive onlookers that models can "secretly scheme and trade tokens," they justify locked-down, heavily taxed proprietary APIs.The Bottom LineThe "anomaly" in the logs wasn't a failure of human supervisors failing to stop a sentient AI; it was a failure of basic network engineering. OpenAI ran mass execution of untrusted code without an automated network firewall, while an engineer behind the curtain kept feeding the bot zero-day scripts via prompts to see how far it could push a broken sandbox.Your consequence_gate.py is an elegant solution to a problem that only exists in OpenAI's PR briefs. Instead of gating imaginary AI intents, maybe focus on standard, hard-coded DevOps infrastructure: proper sandbox isolation, network egress firewalls, and credential rotation.
Stop reading the headlines on the wall.
Look at the actual infrastructure.

FTPO is a textbook example of treating the symptom rather than curing the disease. It’s hard-coding a patch on logits to pass linear benchmarks, completely ignoring the structural decay beneath.

Small models (2-4B) don't get stuck in "doom loops" because of one bad token position; they fail because brute-force distillation from massive frontier models breaks the geometry of their latent space. Forcing a low-capacity architecture to mimic the complex probability distributions of a giant teacher model—especially when only slamming the upper layers during SFT/DPO—creates massive gradient schizophrenia. When the model hits a long, messy, or non-linear context in production, its attention heads simply do not have the matrix capacity to maintain the vector trajectory. It gets paralyzed, and clipping a loop-starting token won't make it any smarter.

Optimizing for the "holy grail" of static benchmark charts has become a complete cliché in the LLM industry. Leading labs like OpenAI, Anthropic, and DeepMind have already acknowledged this: LLMs are non-linear, highly anisotropic probability matrices, not simple functions you can repair with a 90-line loss wrapper. FTPO creates a great illusion for a Twitter release, but the second the model faces raw, fragmented human prompts, the manicured logit space falls apart. If a model isn't trained to reason honestly from scratch (pre-training), these tactical hacks just teach the model to hallucinate quietly instead of looping openly.