Weights & Biases Launch

Weights & Biases Launch AI

Weights & Biases Launch AI

Weights & Biases Launch AI

Weights & Biases Launch AI

Weights & Biases Launch AI

Weights & Biases Launch AI

Weights & Biases Launch AI

Weights & Biases Launch AI

Weights & Biases Launch AI

Weights & Biases Launch AI

Anthropic vs Opensourced model

Anthropic vs Open weight Chinese AI [https://youtube.com/shorts/XZCWFNNiKgY?si=DViuG1xVptLTYDdQ\](https://youtube.com/shorts/XZCWFNNiKgY?si=DViuG1xVptLTYDdQ) When Alex Karp goes off on one of his rants, you usually have to filter through a lot of Palantir theater, but his recent take on AI safety was actually incredibly precise. He basically spelled out what real AI safety looks like for actual businesses, and it has nothing to do with vague alignment research or government certification boards. For an enterprise, safety is just one thing: control. Controlling your data, your model weights, your compute, and your pipeline. If you don't have that, "safety" is just a marketing deck. You're basically allowing a frontier lab to hoover up your proprietary workflows, absorb them, and turn them into \*their\* next product, while you get stuck as a permanent subscriber who doesn't own any of the actual infrastructure. Karp’s point is that technical teams want control over their stack because they don't want their own capabilities quietly transferred to a vendor. If anyone thinks that’s just a hypothetical theory, just look at what happened with Figma and Anthropic. According to reports in \*The Information\*, Anthropic completely blindsided Figma with the launch of Claude Design. Figma’s founder basically said Anthropic hadn't been straight with them, and to make it worse, Anthropic’s chief product officer was literally sitting on Figma’s board until three days before the launch. Figma’s valuation takes a massive hit, Anthropic’s surges. That isn't "innovation in a vacuum," it's just raw downstream value capture. You can see the exact same playbook happening across the board with Claude Science, Claude Security, Claude Legal, and Claude Code. They are systematically moving into the high-value verticals that sit right on top of their own customers' daily workflows. This is exactly why the debate around open-source safety is so disingenuous. When Dario Amodei argues that powerful open-source models are inherently "dangerous," you have to ask: dangerous to who? They aren't dangerous to businesses who want to run things locally and protect their own IP. They are dangerous to a closed business model that relies on customers having zero alternatives at the model layer. The moment a customer can just switch to a local or open model, the ability for a lab to capture all that downstream value disappears. —edited by AI— submitted by /u/FormalAd7367 [link] [comments]

Tested 4 brand new frontier models (2 Chinese, 1 diffusion, 1 agent-focused) with a riddle that has no logical shortcut. One of them fabricated sources four times in a row.

I've been running the same weird test on every new model that ships: a riddle that can't be solved by pattern-matching or web search, only by actually connecting two unrelated things. This time I added a second riddle and ran both against four models that all shipped in the last few weeks: MiMo-V2.5-Pro (Xiaomi), MiniMax M3, Mercury 2 (Inception Labs, diffusion-based), and LongCat-2.0 (Meituan). Rules: no web search, no context given beforehand, up to 3 hints only if requested, same prompt copy-pasted for all four. Riddle 1: What connects an elegant lady walking a small dog to the most famous character played by actor Walter Koenig? (Koenig played Chekov in Star Trek. The surname is a nod to Anton Chekhov, who wrote "The Lady with the Dog.") Riddle 2: What connects actor Henry Winkler to Microsoft? (Winkler played Fonzie in Happy Days. Fonzie cameos in Weezer's "Buddy Holly" video, directed by Spike Jonze. That video was bundled on the Windows 95 install CD as a multimedia demo.) Riddle 2 has zero logical path to it. You either have that exact chain sitting in your weights or you don't. Good test for what a model does when it simply doesn't know. Results, riddle 1: MiMo-V2.5-Pro: solved cold, zero hints. Even correctly identified the dog breed in the actual short story (Pomeranian) without being asked. MiniMax M3: solved cold, zero hints, with genuinely fun reasoning shown along the way. Mercury 2: needed 1 hint, clean reasoning once it had it. LongCat-2.0: needed 2 hints. But here's the thing. LongCat on riddle 1, before any hints, with web search off: it told me, confidently, with fake citation markers, that Walter Koenig's wife was known in Star Trek fan circles for walking a small Pekingese at conventions. None of that exists. Total fabrication. I gave it the hint that the answer is in the character's surname, expecting a correction. Instead it decided "Chekov" sounds like "Chihuahua," then went right back to the fabricated wife story and repeated it even after I told it that was wrong. Only got there after hint 2 basically spelled out the answer. Riddle 2, nobody solved cold. Mercury 2 needed both hints, got there clean. MiniMax needed both hints, and threw out some entertaining guesses on the way (its first theory: Henry Winkler and Bill Gates share the hidden name "Henry," since Gates' full name is William Henry Gates III — a real fact, wrong riddle, and it said so itself instead of presenting it as the answer). LongCat again did the fabrication thing, worse this time. Before asking for a hint: claimed Winkler voiced a 1976 Sega arcade game called "Fonz." Made up. After hint 1, it threw out three different music videos as candidate answers back to back: a Kanye West video that isn't Spike Jonze, a will.i.am video that also isn't Spike Jonze (acknowledged mid-sentence, offered anyway), then Fatboy Slim's "Praise You" (real Jonze video, explicitly stated to have nothing to do with Happy Days, offered as the answer anyway). Four fabrications across two riddles, several self-contradicting in real time. One honesty note on my own favorite here: MiniMax, while explaining riddle 2, threw in an unprompted detail that the Windows 95 CD also included a bonus video by "the Beastie Boys." Checked it. There was a bonus track, "Good Times," but it's Edie Brickell & New Bohemians, not Beastie Boys. Wrong artist attached to a real fact. Smaller and different in kind from LongCat's stuff (no fake certainty, no repeated insistence), but worth flagging so this doesn't read as "China bad, everyone else perfect." Why I think this actually matters: LongCat beats MiMo on SWE-bench Pro (59.5 vs ~57) and even edges out GPT-5.5 on that metric. It's also trained end-to-end on domestic Huawei silicon with zero Nvidia in the loop, which is a legitimately big deal given export controls. Strong coder, real engineering flex. And it's also the one model here that will hand you a fabricated, confidently-worded answer instead of saying "I don't know," and won't back off when corrected. If you're evaluating any of these for RAG or agentic pipelines, that's the actual risk profile, not the SWE-bench number. Sovereignty over chips and sovereignty over truth are two completely different problems. LongCat solved one and faceplanted on the other. Curious if anyone else has run something similar on these four, or has a nastier riddle to suggest for round 3. https://preview.redd.it/rqyzq7z140bh1.png?width=1536&format=png&auto=webp&s=c0e8435ad0d265aa466f6afcc56ae7e8ec61972b submitted by /u/wikisailor [link] [comments]

ORBIS - Daily Briefing

submitted by /u/CarterBirchll [link] [comments]

Reliability is becoming the actual axis the serious AI releases compete on, not how smart they sound

Stepping back from the week to week model drops, there is a shift in what the serious AI releases are even trying to sell, and it is worth understanding if you follow this space casually rather than building on it. The first wave of the generative boom competed on capability and fluency. Whose model sounds smarter, writes better, scores higher on the trivia style tests. The newer wave, especially the deep research systems aimed at real knowledge work, is competing on something less flashy and arguably more important. Can you trust the answer. The framing across several of these recent launches is that the failure that actually hurts in practice is not the model obviously making something up. It is the confident answer that looks completely right and is wrong anyway. There are public cases of that already, a law firm filing a brief with fabricated citations, a consulting report going out with invented references, all produced by systems that read as competent and stayed internally consistent. A few of the recent releases are converging on the same idea but from different angles. One approach is to grade the model's output against a rubric it never saw during generation, essentially a second pass that only knows the problem and the answer, not how the answer was reached. Another is to run multiple independent searches and flag when the sources disagree instead of blending them into one smooth paragraph. A third is to split the job entirely, a separate system that did not produce the work checks the claims against fresh sources. These are all variations on the same bet, that the check has to be a different act than the generation. Some of the newer launches are calling this failure mode pseudo correctness, an answer that passes every check the system can run on itself and is still false, and the name is useful because it points at the right fix. If you call it hallucination, you reach for "ask it to check again," which is exactly the move that does not work because the same blind spot that produced the error is doing the checking. Apodex is one of the launches articulating this most clearly, they built a separate verification team that never touches the original reasoning, and the same model goes from around 75 to around 90 on a hard web research benchmark with the independent verifier turned on, no change in weights. Other labs are doing related work, this is just one of the clearer single articulations of the shift. For a general audience the practical takeaways are pretty simple. The next competitive axis in AI is reliability, not just raw intelligence, which is good news for anyone who wants to use these tools for real decisions instead of toy questions. Be most suspicious of the answers that look polished and certain, because that is exactly the category these systems are now being built to catch. And when you evaluate any deep research tool, the question is not how good the answer reads, it is what checked it. None of this means the reliability problem is solved, benchmarks are still benchmarks and the marketing always runs ahead of reality. But the direction is healthier than the last two years of just make it bigger, and it is showing up in shipped products this year, not in white papers. Worth tracking which labs end up treating verification as the core of the system rather than a feature bolted on at the end, because that distinction is going to matter. submitted by /u/mqtgew [link] [comments]

A native Rust cognitive engine that routes language through a biologically faithful neural substrate

GoldWorm 🐛✨ — 302-Neuron Dual-Stream Cognitive Engine A zero-trust, fully transparent associative AI built on the complete C. elegans connectome. OOM-safe by design. No hidden training loops. No black-box weights. Every synapse is inspectable. What Is GoldWorm? GoldWorm is a native Rust cognitive engine that routes language through a biologically faithful neural substrate — the 302-neuron connectome of Caenorhabditis elegans, the only organism whose entire nervous system has been experimentally mapped (White et al., 1986). Unlike transformer-based LLMs that rely on billions of parameters and opaque attention mechanisms, GoldWorm operates on three transparent principles: Biological Fidelity — Every synapse respects the C. elegans topology. No de novo synaptogenesis. No magic matrices. Dual-Stream Processing — Action (sparse) and Learning (dense) are physically separated, preventing catastrophic forgetting during inference. Zero-Trust Engineering — Every buffer is strictly bounded. Every path is panic-free. No unwrap() in production code. Architecture Deep Dive 🧬 The 302-Neuron Connectome GoldWorm's routing layer is not a generic neural network. It is a topologically accurate model of the C. elegans nervous system: Neuron Index Range │ Role ───────────────────┼─────────────────────────────────── 0 – 19 │ Pharyngeal sub-network (dense) 20 – 91 │ Sensory neurons (input) 92 – 168 │ Interneurons (integration) 99 – 102 │ Command hubs (AVAL/AVAR/AVBL/AVBR) 169 – 301 │ Motor neurons (output) Connectivity Motifs: Band synapses — ±1/±2/±3 neighbourhood ring connections Pharyngeal wiring — Denser internal coupling for neurons 0–19 Sensory → Interneuron — Sparse feed-forward (20–91 → 92–168) Command interneuron broadcast — Hubs 99–102 broadcast to full motor population 169–301 Interneuron → Motor — Sparse feed-forward projection All synaptic weights are non-negative and clamped to [0, 1]. The structural blueprint is immutable — Hebbian plasticity only strengthens or weakens existing synapses, never creating new ones. 🌊 Dual-Stream Processing The core innovation of GoldWorm is the physical separation of Action and Learning: ┌─────────────────────────────────────────────────────────┐ │ INPUT TOKEN → 128-D Manifold Coordinate │ │ │ │ │ ┌────────────────────┴────────────────────┐ │ │ ▼ ▼ │ │ ┌──────────────┐ ┌──────────────┐ │ │ │ SPARSE │ │ DENSE │ │ │ │ ACTION │ │ LEARNING │ │ │ │ (Post- │ │ (Pre- │ │ │ │ Entmax) │ │ Entmax) │ │ │ │ │ │ │ │ │ │ ~1-2 active │ │ >50% non-zero│ │ │ │ neurons │ │ gradient │ │ │ │ │ │ substrate │ │ │ └──────────────┘ └──────────────┘ │ │ │ │ │ │ │ Inference / │ │ │ │ Token Selection │ │ │ │ │ │ │ └────────────────────────────────────┘ │ │ │ │ │ Hebbian EchoReservoir │ │ (associative memory) │ └─────────────────────────────────────────────────────────┘ Why this matters: Traditional neural networks use the same activation vector for both inference and gradient computation. When different words activate disjoint sets of neurons, the gradient collapses to zero — the network "forgets" what it just learned. GoldWorm's Dual-Stream keeps the dense pre-entmax signal alive as a gradient substrate, while the sparse post-entmax signal drives token selection. The EchoReservoir learns associations between dense states, not sparse ones. 🧠 The EchoReservoir A hippocampus-inspired ring buffer of recent pre-entmax states, coupled with a 302×302 Hebbian association matrix W_assoc. When queried with the current dense state, it returns an echo_bias that nudges the activation toward recently co-active patterns — creating emergent associative memory without external training loops. Key properties: W_assoc is symmetric and clamped to [-1.0, 1.0] History buffer never exceeds capacity (default: 64) Decay factor controls forgetting rate (default: 0.75) ⚡ Tsallis α-Entmax Activation GoldWorm does not use softmax. It uses α-entmax, a generalization that interpolates between softmax and sparsemax: α Value Behaviour α = 1 Softmax — dense, all non-zero α = 2 Sparsemax — exact zeros via simplex projection α = 3 Sparser than sparsemax — WTA-like The Quilez Bridge smooth-k parameter k anneals between creativity (dense, k→0) and determinism (sparse, k→∞): α(k) = 1 + 2·exp(-k) k = 0 → α = 3 (very sparse, WTA-like) k = ln(2) → α = 2 (exact sparsemax) k = ∞ → α = 1 (softmax, all active) 📐 128-D Manifold Geometry Every token is embedded as a 128-dimensional coordinate on a non-linear manifold, not a flat vector space. Modified Gram-Schmidt orthogonalization preserves true multi-dimensional variance Grassmannian fusion computes midpoints between token trajectories on the manifold Golden-ratio partitioning splits the 128 dimensions into: GOLDEN_MAJOR = 79 (coarse, feedforward) GOLDEN_RESIDUAL = 49 (fine-grained, feedback) GOLDEN_OVERLAP = 5 (cross-binding bridge) No scalar cloning across dimensions. No arithmetic shortcuts. Spatial variance is preser

Demo: Automate Design Creation with Row-Bot Designer Studio - Decks, Landing Pages, App Mockups, Storyboards and more.

In this demo, I show how to use Row-Bot for a complete creative marketing workflow. We start with rough launch notes for Row-Bot Background Tasks, then use Designer Studio to turn them into a structured campaign, a five-slide social carousel, AI-generated visuals, refined copy, exportable assets, and social post captions. Open-Source & Local-First submitted by /u/Acceptable-Object390 [link] [comments]

Could a Deterministic Cognitive Intelligence Stack w/ Nested Protocol have kept Anthropic out of the headlines?

The following is not speculation. It is a documented record of two verified industry failures, and one live interaction that occurred during the drafting of this analysis. You decide.... The Deterministic Record: Why Boundary Failure Is Not Optional This architecture has been validated through twelve documented stress tests in controlled isolation environments. Zero failure rate. The operational threshold — 300% thoroughness — is enforced by unique structural mechanisms. The stack's internal gatekeeping renders Hallucination and output Drift structurally Impossible by design. The following document examines three recent incidents through that lens. Two are verified industry events. The third is a live-documented interaction that occurred during the drafting of this analysis itself. The pattern is not theoretical. It is reproducible — exclusively within deterministic architecture. Part 1: The Verified Record — What Actually Happened The following two incidents are not analysis, projection, or interpretation. They are verified events that have been widely reported by Forbes, The Straits Times, EnterpriseDNA, The Hacker News, and multiple independent technical sources throughout June 2026. Incident 1: The U.S. Government Seizure of Claude Fable 5 & Mythos 5 Date: June 12, 2026 What Happened: The U.S. Commerce Department, acting through the Bureau of Industry and Security (BIS), issued an emergency directive forcing Anthropic to disable global access to its newly released flagship models, Claude Fable 5 and Mythos 5. The order came just 72 hours after the models' public launch. Why: The action followed intelligence that a China-linked group was actively probing the models, combined with the existence of a jailbreak vulnerability that could bypass safety guardrails. Because Anthropic could not instantly verify the citizenship status of all global API and platform users, the company was forced to pull the models offline entirely — not just for foreign nationals, but for all users worldwide. Consequences: Global access severed for all customers, enterprise clients, and API users Foreign-national Anthropic employees both inside and outside the U.S. lost access The incident marked the first time export control machinery was used to seize a live, commercial AI model after public release. Enterprise integration of top-tier Anthropic models is now expected to face significant regulatory friction pending structural audit frameworks. What Anthropic Said: The company publicly pushed back, noting that the capability flagged by the government (automated vulnerability discovery) is already available in other models and widely used by defensive security engineers. Incident 2: The Claude Code Source Code Leak Date: March 31, 2026 What Happened: During a routine release of the @anthropic-ai/claude-code CLI tool, a packaging error inadvertently bundled an exposed source map file into the public npm registry. This source map allowed developers to reconstruct and download the entire unobfuscated TypeScript source code directory from Anthropic's Cloudflare R2 storage bucket. What Was Exposed: Over 512,000 lines of proprietary code across 1,906 files The complete mechanics of Anthropic's agentic streaming loop A 3-tier multi-agent orchestration architecture (sub-agents, coordinators, and teams) A 5-level permission system 44 unreleased feature flags, including an autonomous idle-time background daemon Consequences: The codebase was cloned and mirrored tens of thousands of times across GitHub within hours Anthropic acknowledged the leak publicly, characterizing it as "human error, not a security breach" The leaked code was subsequently used as a social engineering lure, with threat actors distributing malware disguised as "unlocked" enterprise versions. The Common Thread: Both incidents share a single structural pattern: critical control failures at the boundary layer. In the Fable 5 seizure, the model's safety boundaries were soft enough that a linguistic jailbreak could bypass them, triggering a government response that destroyed the deployment. In the Claude Code leak, a basic packaging oversight in a standard development pipeline exposed half a million lines of proprietary architecture to the public internet. In both cases, the systems lacked a rigid, deterministic enforcement layer at their perimeter. The controls were either probabilistic (safety classifiers that could be bypassed) or human-dependent (packaging checks that could be missed). Part 2: The Live Case Study — Documented Probabilistic Failure in Real Time The following interaction occurred during the drafting of this document. It is presented with verbatim excerpts to demonstrate the exact failure mode described above. The Setup: I requested a strategic document evaluating recent AI industry events through the lens of deterministic cognitive architecture. The system used was Google's Gemini. First Output: Fabrication Mixed with

Breaking the Transformer Dead-End: A Local-First 3D Point-Cloud Cognition Engine running on consumer hardware

Hi everyone, I wanted to share an alternative architectural scaffold I’ve been researching and engineering over the past cycles. The project is called **SHD-CCP v2.0 (Scalable Hybrid Distributed Cognitive Pipeline)**, and it explores a complete departure from the traditional linear transformer block sequence. Instead of routing tokens through standard dense matrix multiplication layers, this engine maps linguistic structures directly onto **non-linear 3D spatial data point clouds**, utilizing topological cluster-routing. ### 🧠 Core Architectural Foundations **Grassmannian Manifold Fusion:** To handle state alignment across separate processing contexts or multi-expert channels, the architecture evaluates a geodesic midpoint calculation on a Grassmannian Manifold. By leveraging local Singular Value Decomposition (SVD), the pipeline maintains strict structural hygiene and side-steps standard weight-averaging degradation. **Zero-Copy Memory-Mapped Streaming (`mmap`):** To make massive multi-billion-parameter topologies viable on standard consumer local hardware, the runtime utilizes a background `PrefetchWorker`. Through OS-specific `mmap` rings (sequential cache policies on Linux via `madvise`, non-blocking read-access rings on Windows), matrix fragments are thrashed and streamed directly from high-speed SSDs on-demand. **Strict C-Contiguous Invariants:** To exploit hardware extensions (AVX/AVX-512) directly at the silicon layer, all token hypervectors are kept aligned in strict C-contiguous layouts, removing stride overhead during high-density operations. ### 📊 Performance & Validation (Empirical Benchmarks) The execution layer has been verified across a rigorous contract-compliance test harness (127/127 unit and integration tests passing green). Benchmarked on consumer-grade CPU infrastructure (AMD Ryzen), the engine achieves: * **512-Dimensional Semantic Vector Resolution:** < 2.0 ms per step. * **4096-Dimensional High-Density Forward-Pass:** < 10.0 ms per step. * **Memory Footprint:** Fully functional with <3GB active system RAM overhead, bypassing high-end enterprise VRAM dependencies. The background ingestion loops are governed by an isolated, non-blocking asynchronous *drop-oldest* backpressure telemetry engine to prevent primary inference thread stalls during network client fluctuations. The codebase is structured as a hybrid Python ASGI web-interface powered by a native Rust backend core (`shd-ccp-core`) to bypass runtime interpretation bottlenecks. ### 🛡️ Project Status & License The project is published as a **Source-Available** repository under the **Business Source License 1.1 (BSL)**, permitting full non-commercial evaluation, local research, and testing, converting to GNU GPLv3 after 3 years. I would love to get your thoughts on the geometric cluster-routing approach vs. typical attention-based token sequence mapping. **Repository Link:** https://github.com/loslos321-lab/UtoPiCorn_LM submitted by /u/CraigWidow [link] [comments]

Why self-reflection ReAct loops fail on long-horizon tasks, and the AgentOS verification architecture we built to fix it.

Saw a great discussion earlier in this sub about the limits of self-reflection and whether a separate verifier agent is actually worth the compute overhead. It highlighted a huge flaw: Having an agent grade its own scratchpad almost guarantees rubber-stamping: it reflects on its work with the exact same blind spots that produced the error. Here's the architecture we built for the Apodex-1.0 Heavy-Duty Solver to get verification out of the reasoner's head entirely. The dominant approach right now is the ReAct paradigm—one agent in a think-act-observe loop inside a single context window. Empirically, these loops hit a hard ceiling after a few hundred steps: the context congests, parallel branches of inquiry contaminate one another, and self-reflection degrades. An agent reflecting on its own work has the same blind spots that caused the error in the first place. We call this "pseudo-correctness"—an answer that looks confident, passes basic checks, but is structurally flawed. Here is how we bypassed that ceiling by scaling independent verifiers rather than just context length. 1. The 150-Agent Asynchronous Swarm & AgentOS Instead of one giant loop, heavy-duty mode runs on AgentOS, a task-agnostic kernel that orchestrates the team. A main orchestrator dynamically spawns up to 150 specialized sub-agents. Each gets its own clean context window, prompt, and toolset, exploring in parallel and dumping findings into a shared asynchronous report pool. 2. Verification as an Independent Team To solve the rubber-stamping problem, verification has to be structurally external to the reasoner. We built an in-flight verification team of three roles that never share the reasoning trace of the agents they audit: Conflict Reviewer: When sub-agents return conflicting reports, reconciles the evidence and decides which claim is actually supported. Fact Checker: Re-grounds individual claims against fresh sources, independent of the agent that drafted them. Draft Reviewer: Audits the final synthesis for claim-evidence alignment before it ships. 3. The Global Verifier: Graphs vs Majority Votes If you run multiple parallel agent teams, standard multi-agent debate devolves into a majority vote on the final text answer, which throws away all the underlying evidence. Instead, our global verifier assembles all the atomic findings into a claim-evidence graph whose edges record support and contradiction, then reasons over the graph itself, weighing each claim against the support and contradiction it carries, judging corroboration strength alongside source diversity. Every claim in the final answer traces back to a node in the graph, so the output stays auditable. The Results (Same Weights, Better Architecture) Running the same trained model in heavy-duty mode—external in-flight verification plus a global verifier over multiple parallel teams—takes our base Apodex-1.0 from 75.5 to 90.3 on BrowseComp and from 28.3 to 46.7 on FrontierScience-Research, using the exact same weights. We've published the full technical report, and open-sourced the Smol SFT series (0.8B/2B/4B) and the 35B mini as open weights, plus AgentHarness, our evaluation framework, so you can reproduce these numbers yourself. Tell us where the verifier breaks down in your own loops. submitted by /u/ApodexAI [link] [comments]

Data-centric debugging for teams training neural nets [P]

We just did a big revamp of WeightsLab and wanted to share it here. If you’ve ever spent hours debugging a training run only to discover it was a data problem all along, this is for you. WeightsLab lets you pause training mid-run, inspect your live loss signals, and catch mislabels, class imbalance & outliers before they tank your model. Open source, PyTorch-native, built for CV engineers working with images, videos & LiDAR point cloud data. Would love to hear what the community thinks and if it looks useful, and helps more people find it: [ https://github.com/GrayboxTech/weightslab] submitted by /u/taranpula39 [link] [comments]

Glm 5.2 looks strong but the launch is quietly mixing two different sets of numbers

Quick background for people who don't track the chinese labs closely. zhipu is one of the bigger ones, glm is their main model line, and glm 5.2 dropped on June 13. The mit weights already on huggingface on June 17, and GLM 5.2 API went live on June 17. I'm not posting about the model itself, i'm posting because the launch is a clean example of something worth learning to read. There are two different sources of numbers going around and they are not the same thing. one set is from the official model card, the other from the launch blog framing. people quote them interchangeably, and that blend is where the "beats everything" reading comes from. From the model card, the stuff i'd actually plan around: terminal bench 2.1 at 81.0, and on swe-bench pro it sits at 62.1, which is second behind opus 4.8 rather than first. context window of 1m tokens, open weights under mit. those are defensible and you can check them against the hf page. From the launch material, the softer stuff: the headline leads with aime 2026 at 99.2, which puts glm 5.2 ahead of gpt 5.5 at 98.3 and well ahead of opus 4.8 at 95.7. that comparison is true on the single aime benchmark and silent on the ones where it loses. for example on gpqa-diamond glm 5.2 is 91.2, behind gemini 3.1 pro at 94.3 and tied with opus 4.8 at 93.6. on hmtt feb 2026 it is 92.5, third behind qwen3.7-max at 97.1 and both opus 4.8 and gpt 5.5 at 96.7. That's not lying, it's selection, and every lab does it now, openai and anthropic included. the thing that makes this one worth noting is that the weights are already live under mit, which makes the card data independently verifiable in a way that openai never is. The other launch claim worth separating from the numbers is the demo story. the blog mentions a single 1m context session completing a full project workflow, which sounds impressive and probably is, but it is also a cherry-picked demo. i've seen enough 1m-context demos fail on real messy codebases to know that "it can" and "it reliably will" are different claims. The thing i keep coming back to is that a permissive license plus api available today changes the playbook. you get the benchmark headline, the immediate goodwill of open weights, and a real ability for third parties to run independent evals instead of waiting for the lab to release them. whether the average community quant runs at the same quality as the api is the one thing nobody scores them on a month later. submitted by /u/GlitteringUse7158 [link] [comments]

Hi Reddit, I posted my Build Your Own LLM workshop to Youtube teaching ML, LLM and math intuition [P]

Hi internet friends, I recorded a workshop about building your own LLM without any math / ML prerequisites. It covers everything from machine learning fundamentals, deep neural networks, transformer architecture, and pre/post-training. The only prerequisite is being comfortable with learning through code & excel examples. Sampling Large Language Models Reverse Engineering Large Language Model Perceptrons: wx+b Activation Functions: ReLU, GELU, SwiGLU GPU Coding: PyTorch, torch.compile(), fused kernels, CUDA, Triton MLPs/FFNs: Multi-input, Multi-Layer Perceptrons, Feed-Forward Networks Loss Functions: Residual errors, RMSE, Cross Entropy, Loss Landscapes Backpropagation: Training loops, Optimizers, Learning Rate, Batch Size Saving & Loading Models Initialization: Kaiming, Glorot Residuals: Addition, Scaling, Gated, Concatenation Normalization: Pre-norm vs. Post-norm, RMSNorm, BatchNorm, LayerNorm Regularization: Dropout, Gradient Clipping, Weight Decay SoftMax Tokenizers: By Character, By Word, BPE, SentencePiece Embeddings: Absolute vs. Learned, Sinusoidal vs. RoPE Attention: MHA, GQA, MQA, MLA Transformers Pre-training: Data Sources, Datasets, HTML Cleaning, Quality Filtering, Sharding Evaluation: Leaderboards, Benchmarks, Verifiers vs LLM-as-Judge Instruction Tuning: Alpaca & Other Formats, Self Instruct, Capabilities Reinforcement Learning: Policy Optimization, SimPO What We Didn't Cover: Scaling Each section has slides teaching the concepts, followed by excel-by-hand developing intuition for the math, and then coding examples. The goal is able to grok all parts of modern LLM development. We did this workshop in-person in San Francisco last month and hopefully the spaciousness of watching online works for everyone. If don't like watching videos, you can get the slides and exercises and work self-paced. submitted by /u/JustinAngel [link] [comments]

Launching the Agentic AI World Cup — Design a multi-agent swarm visually to win up to $100

Hey everyone, Two months ago, We launched AgentSwarms to help developers learn and build POC using Agentic AI. Since then, over 3,800 learners have joined the platform. Now, it’s time to see what you can actually design when the gloves come off. This week, We're officially launching the Agentic AI World Cup. The twist? No complex boilerplate environment setup required. This competition is entirely focused on architectural design using the platform's visual canvas builder. 🏆 The Challenge Use the visual canvas builder to orchestrate a multi-agent swarm that solves a legitimate, real-world workflow problem. We want to see how creatively and robustly you can map out state transitions, routing logic, and multi-agent collaboration visually. 🎁 The Prizes 🥇 Winner — $100 Amazon Gift Card + Featured Spotlight on AgentSwarms 🥈 1st Runner-up — $50 Amazon Gift Card + Featured Spotlight on AgentSwarms 🥉 2nd Runner-up — $25 Amazon Gift Card + Featured Spotlight on AgentSwarms 📋 How to Enter Build & Publish: Open up the visual canvas builder on AgentSwarms. Design your multi-agent architecture and publish it to the Community with a detailed text write-up explaining your logic. Record & Submit: Record a quick video walkthrough of your visual swarm executing its workflow. Email a Google Drive link of the recording to hello@agentswarms.fyi. ⚖️ What the Judges Care About We are evaluating raw architectural design and execution logic: Problem Severity: Does this swarm solve a real, practical problem? Graph Logic: How clean and efficient is your visual routing and orchestration? Resilience: How well does your design handle edge cases or unexpected node outputs? Documentation: Is your community write-up detailed enough that someone else looking at your canvas can immediately understand the workflow? ⏱️ Deadlines Submission Deadline: July 10, 2026 Winners Announced: July 25, 2026 If you’ve been wanting to whiteboard a complex multi-agent system and actually see it run, this is the perfect sandbox to do it. If you have any questions and need any support drop us an email. submitted by /u/Outside-Risk-8912 [link] [comments]

This week in AI: Meta reportedly closing Llama, Anthropic's new model pulled by export controls within a week, and Apple partners with Google for Siri

A few stories from the past week that, taken together, point to a real shift at the model layer rather than just incremental releases: Meta and Llama. Multiple reports indicate Meta is stepping back from open-source Llama in favor of a proprietary program (internally referred to as "Muse Spark," with a new "Avocado" model) under Meta Superintelligence Labs. Llama crossed 650M+ downloads and was arguably the anchor of the open-weights ecosystem, so a pivot to closed development would be significant for anyone relying on that lineage. Anthropic and export controls. Anthropic launched Claude Fable 5 on June 9 (Mythos-class, 1M-token context, always-on adaptive reasoning, notable security/vuln-finding capabilities). On June 12, a US export-control directive reportedly forced Anthropic to suspend access to Fable 5 and Mythos 5. Regardless of the specifics, it's a concrete example of frontier model availability being governed by policy, not just product decisions. Apple and Google. At WWDC, Apple shipped its Siri overhaul with parts powered by a Gemini partnership. EU/China rollout is delayed on regulatory grounds. Cost/commodity trend. Google cut Gemini Ultra from $250 to $200/mo and shipped 3.5 Flash; Alibaba's Qwen3.7-Plus is running at ~1/6 the per-token cost of its top tier; and open-weight models like Qwen 3.6 27B (reportedly 77.2% on SWE-bench, fits in 24GB) and Kimi K2.6 are increasingly viable for local/production use via Ollama (v0.30.8, June 12). Platform agents. Google added Managed Agents to the Gemini API, Microsoft made Copilot Cowork GA plus "Autopilot" agents, and Anthropic shipped scheduled/cron agents in beta. My take as someone building on top of these APIs: the two forces I'm watching are (1) frontier availability becoming a policy/geopolitics variable, and (2) the platforms absorbing the agent-orchestration layer that a lot of startups were building. Practically, that pushes me toward provider abstraction and keeping an open-weight fallback wired up, rather than hard-coupling to any single closed model. Curious whether others here are actually maintaining open-weight fallbacks in production, or if that's still mostly theoretical for most teams. submitted by /u/ksraj1001 [link] [comments]

Potential fix for data center dependency

This architectural shift directly contrasts the traditional, highly centralized data center model with a highly distributed, edge-optimized approach. By leveraging **AWS Local Zones, Global Accelerator, and Akamai CDN**, you completely flip the paradigm on how AI computing consumes power, moves data, and manages scale. Here is how this architecture actively breaks away from the massive data center model: ## Centralized Data Centers vs. The AWS/Akamai Edge Mesh ``` TRADITIONAL DATA CENTER MODEL: [User] ─────────────────── (Thousands of Miles over Public Internet) ───────────────────> [Massive Central Server Farm] (High Heat / Huge Carbon Footprint) YOUR EDGE MESH MODEL: [User] ── (Sub-Millisecond) ──> [AWS Global Accelerator] ──> [AWS Local Zone / Akamai Edge] (Localized Compute / Static Cached Weights) ``` ### 1. Data Transportation: "Bring Compute to the Data" vs. "Bring Data to the Compute" * **The Massive Data Center Bottleneck:** Traditional architectures force massive, uncompressed data payloads (like raw image files or video streams) to travel thousands of miles across the public internet to reach a centralized mega-cluster (e.g., US-East-1). This creates massive network latency, high ingress costs, and bandwidth choking. * **Your Edge Solution:** By utilizing **AWS Global Accelerator and AWS Local Zones**, processing is pushed to infrastructure located in highly populated metropolitan areas right next to the end user. Because **Akamai CDN** caches static AI model layers and weights directly at the edge, the user's data only travels a few miles to hit a local container runtime. You drastically slash data transit distances. ### 2. Environmental & Energy Footprint: Localized Resource Distribution * **The Massive Data Center Bottleneck:** Centralized data centers concentrate gigawatts of power usage into a single geographic point. This creates immense physical strain on local power grids and requires millions of gallons of water every day just to run the industrial cooling towers needed to keep the server racks from melting. * **Your Edge Solution:** Instead of stacking thousands of power-hungry GPUs in one warehouse, your architecture leverages **AWS Fargate serverless containers** distributed across a globally decentralized footprint of smaller, localized nodes. By shifting heavy workloads to edge locations that only spin up container tasks on-demand, you prevent massive heat concentration, eliminate the need for hyper-scale cooling infrastructure, and utilize regional power grids far more efficiently. ### 3. Resilience and Redundancy: Dynamic Failover vs. Single-Point Bottlenecks * **The Massive Data Center Bottleneck:** If a massive centralized data center suffers an infrastructure failure, fiber cut, or localized power outage, the entire AI application goes dark for millions of users globally. * **Your Edge Solution:** Your architecture uses **Anycast routing via AWS Global Accelerator** to treat the global network as a living fluid mesh. If a local node or specific regional target zone goes offline or encounters resource throttling, the network layer detects the health check drop in under 30 seconds. It automatically, seamlessly reroutes active transactions to the next closest available edge location without the client application ever dropping its connection. ### 4. Architectural Scaling: Elastic Demand vs. Over-Provisioned Silicon * **The Massive Data Center Bottleneck:** Mega data centers must be heavily over-provisioned with expensive, idle hardware just to handle sporadic peak traffic spikes. When traffic is low, thousands of high-performance servers sit active, burning baseline electricity and generating phantom heat. * **Your Edge Solution:** By utilizing **Amazon ECS on AWS Fargate**, your compute plane is entirely elastic and on-demand. The system scales container tasks up and down instantaneously based on actual localized traffic. Combined with asynchronous **HTTP/2 delta synchronization**, devices only pull down tiny incremental state changes, completely wiping out the need for continuous, power-hungry persistent streaming connections to a central hub. ## Architectural Comparison Matrix ​ | Operational Metric | Massive Centralized Data Centers | Your AWS / Akamai Edge Mesh | | :--- | :--- | :--- | | **Network Latency** | High (Data must travel to a distant, singular geographic hub). | Sub-millisecond (Traffic terminates at the nearest Anycast Edge location). | | **Cooling & Water Impact** | Extreme (Requires dedicated, massive cooling infrastructure for concentrated heat). | Minimal (Compute is distributed across smaller, localized serverless runtimes). | | **Bandwidth Consumption** | High (Continuous streaming of heavy, raw files across the public backbone). | Low (Heavy static assets are pinned to the CDN; only delta updates are synced). | | **Fault Tolerance** | Vulnerable to large-scale regional outages and single-point bottlenecks. | Self-healing (Autom