praedico

🇫🇷🇫🇷🇫🇷🇫🇷🇫🇷

Claude Fable 5 will be available again globally tomorrow. After a series of productive conversations with the US government, we're redeploying the model with a new set of classifiers to target and block more cybersecurity tasks. In the near term, some routine tasks like coding and debugging will fall back to Opus 4.8. We’ll continue to refine these classifiers over the coming weeks to reduce false positives and better distinguish genuine misuse from legitimate requests. We’ve also begun drafting a consensus framework—with Amazon, Microsoft, Google, and other Glasswing partners—for assessing the severity of AI jailbreaks and how AI developers should respond to them. We invite other industry partners and model providers to join us in this effort. Finally, we’re scaling up our collaboration with the US government on model testing and safeguards. This will include pre-release access to models and safeguards for evaluation, information sharing on jailbreaks and misuse, and dedicated resources for joint research. Thank you to our users for your patience, and to our partners across the government, industry, and the research community who worked alongside us to make Fable 5 available again. Read our full blog: anthropic.com/news/redeployi…

@Batatasfri13181 The real 10x Robotics Engineer 🫵

YC x Unaite Hackathon winner, that’s so incredible! 🚀 I’m not much of a pro with X posting , so I’ll let my mate introduce the project. 😎

This weekend, our team won Paris Builds, a 36-hour selective hackathon by @Unaite, in partnership with @ycombinator. In just 36 hours, we built VIGIE, a robot safety watchdog & harness, an external runtime safety layer for learning-based robots. It watches the robot and its workspace through cameras from the environment, detects dangerous situations, and can pause, hold, and resume a real OpenARM / LeRobot run when the scene becomes unsafe — with a demo harness interfaced with the @LeRobotHF framework. The core idea behind VIGIE is that robot safety should not depend only on the robot policy itself. Today, most robots still operate with little to no external safety harness. The robot executes actions, but there is no independent runtime layer continuously asking: “Is the current scene still safe?” “Is a human hand entering the workspace?” “Is the robot about to continue an action that became dangerous?” We see this as a layered roadmap. Huge shoutout to Joseph @Batatasfri13181 , Maelic, Tristan @tristanlecourt and Raph, amazing sprint. A very special thank you to Alba @leader_arm for helping us set up the OpenARM. Huge thanks as well to @Unaite for organizing the event, and to the mentors, jury members, and partners who pushed us throughout the weekend — including @dessaigne, people from @gs_ai_ , @MistralAI , Qube Research & Technologies, and the broader ecosystem around the event. Big thanks to Stephenson Harwood Paris for hosting us in central Paris. And the cherry on top: winning the hackathon means we earned a YC interview for a chance to join a future batch, which is an incredible opportunity. Repo here: github.com/TristanLecourt…

*** @unaitefr 😭😭

@sneaXOR Ty

@praedico Bien joué !

Excited to be joining the Robotics track at Paris Builds 2026

There’s a big misconception about how GLM 5.2 was trained. Yes, they distilled Claude and GPT 5.5 — but distillation is not how they matched Opus quality. Distillation only fixed the cold start problem in RL. RLing an agentic coding model isn’t rocket science. In simplified terms: 1. RL needs trajectories — rollouts where the model actually completed a task in some env 2. No successful trajectory on a task = zero gradient = you can’t RL it. This is the cold start problem 3. Distillation solves it. You seed your model with knowledge from a smarter one (Claude, GPT) on tasks it can’t do yet 4. Now it produces positive trajectories on those tasks 5. RL on those trajectories and hill climb agentic coding 6. At that point you no longer need to distill and can solely hill climb RL to better models This is an interesting curve. I’d argue it’s harder to get to Opus 4.8 from scratch than to go from Opus 4.8 → Fable/Mythos tier. GLM 5.2 is already producing positive trajectories, so they have plenty to RL on — they’ll keep climbing to Mythos quality without distilling any further. They no longer need American models.

I just open-sourced portable-agentic-sdd-skills. It’s a portable, tool-agnostic skill pack for Spec-Driven Agentic Software Development. The goal is simple: Stop using coding agents as glorified autocomplete, and start integrating them into a real software engineering process. Most AI coding workflows still look like this: “Build this feature.” → agent writes code → tests maybe pass → nobody really knows what changed, why it changed, or whether the implementation still matches the product intent For serious projects, that does not scale. So I built a reusable skill system around a more rigorous workflow: → requirements → use cases → specification → spec review → architecture proposal → architecture review → task decomposition → implementation plan → implementation → test review → design review → E2E validation → spec audit → documentation sync → commit review → release checklist The repository includes portable skills for: - requirements discovery - use-case writing - specification writing and review - architecture proposals and ADRs - architecture fitness functions - task decomposition - implementation planning - coding tasks - test planning and review - root-cause debugging - design review - security review - E2E validation - spec drift audits - traceability audits - documentation sync - commit and pull request review - release preparation The core idea is that each skill is not just a prompt. It is a versioned engineering protocol with: - a clear purpose - required inputs - preconditions - a defined procedure - an expected output format - stop conditions - safety constraints - a quality checklist - anti-patterns The pack is designed to be portable across: - OpenAI Codex - Claude Code - Cursor - open-source coding agents - custom agent orchestrators The canonical skills are plain Markdown, so they are easy to inspect, version, fork, audit, and adapt. Why this matters: For agentic development, the repository must become the durable memory of the system. The spec defines what should be true. The architecture defines the allowed structure. The tests provide evidence. The tasks define bounded execution. Git provides reversibility. The agents execute specialized roles. This is not about adding more bureaucracy. It is about reducing ambiguity, preventing spec drift, separating creation from review, and making AI-assisted development reproducible instead of conversational and fragile. The repo is still early, and I plan to keep improving: - cross-tool adapters - stronger skill validation - traceability automation - company-specific extension - golden tests for skills - benchmark scenarios across coding agents - orchestration workflows for multi-agent development Repo: github.com/0xPraedico/por…

Interesting. (Founder of Z.ai, creator of GLM AI models.)

I just open-sourced Arasaka, a Rust runtime for governed AI agents. The idea behind it comes from a contrast I find increasingly important. Coding agents have become useful not only because models got better, but because their execution environment gives them strong boundaries: diffs, tests, sandboxes, reviews, git history, CI, rollbacks. A coding agent can act, but its actions are constrained, inspectable, and reversible. Most “business agents” do not have an equivalent layer yet. They connect LLMs to CRMs, databases, ticketing systems, browsers, internal APIs, memory, workflows, customer data, and operational systems. But the governance layer is often thin, scattered across prompts, glue code, dashboards, and a few ad hoc checks. That feels backwards. The more powerful the tools become, the less authority the model itself should have. Arasaka is my attempt to build that missing runtime layer. The philosophy is simple: LLM output should be treated as a proposal, not as authority. The model can suggest an answer, a tool call, a write, a workflow step, or an escalation. But the runtime should decide what is allowed, what needs validation, what requires human approval, what must be idempotent, what belongs to which tenant, what context is authoritative, and what needs to be recorded for audit. Some of the pieces I’m excited about: governed ReAct execution policy-gated tool calls approval checkpoints resumable workflows auditable RunTrace output tenant-aware memory and retrieval GraphRAG for authority-aware context and lineage DomainPacks for packaging tools, policies, evals, and workflows eval datasets for testing governance behavior over time CLI + HTTP surfaces so the runtime can be used as infrastructure, not just a demo My bet is that business agents will not become reliable just by plugging better models into more tools. They will become reliable when their execution environment starts looking more like serious software infrastructure: observable, auditable, permissioned, reversible, testable, tenant-aware, and governed by design. That is what Arasaka is trying to explore. Open source here: github.com/0xPraedico/ara…

Exciting news: GLM-5.2 (Max) ranks #2 in Code Arena: Frontend, with +29pt over Claude Opus 4.7 (Thinking) and only behind Fable 5! GLM-5.2 is the best open model vs Kimi-K2.6 and Minimax-M3 by a large margin. - #2 React and #4 HTML sub-leaderboards - Ranks as the top model in nearly all sub categories: Brand & Marketing, Reference-Based Design, Data & Analytics, Consumer Product, Gaming, and Simulations. Congrats @Zai_org for the incredible milestone!

hackathon maxxing

We're excited to join forces with @SpaceX to advance the frontier of useful AI. Expect significant improvements to Cursor soon.

I built a haunted computer for the Hugging Face Build Small Hackathon. KERNEL-95: The Last Desktop is an AI-native forensic horror game set in 2077. You join the KERNEL-95 Recovery Division to investigate Device 013, an obsolete computer recovered from a sealed MetroGrid Behavioral Lab archive. It has no power source, yet it is still running. Three technicians touched it. Each lost exactly thirteen minutes of memory. To enter the machine, you connect MIRROR.exe, your assigned forensic AI assistant. Inside its corrupted retro desktop, you recover deleted messages, compare restore points, run contradiction scans, interrogate MIRROR and search for ECHO, an unknown intelligence hiding inside the system. But MIRROR is not a neutral assistant. She evades questions, rewrites her testimony and suppresses evidence because she is secretly protecting ECHO. The core design principle is : “The AI plays the unreliable witness. The deterministic engine protects the truth.” Qwen performs MIRROR’s diversions, contradictions and emotional admissions in response to the player’s own questions. The player can classify her testimony, but only deterministic forensic tools can establish facts, unlock evidence or change the case. At the end of Case 013, you decide whether to delete ECHO, extract him, expose MIRROR, protect them both, or allow something impossible to survive inside the last desktop. Built with: • Gradio from @Gradio for the game and custom retro interface • Qwen/Qwen3-4B-Instruct-2507 for MIRROR and ECHO • vLLM on Modal from @modal for inference • OpenAI Codex as my coding agent • A deterministic Python investigation engine for truth and progression Built for An Adventure in Thousand Token Wood. Also entering the OpenAI and Modal sponsor tracks, with Tiny Titan and Off-Brand achievements. Play KERNEL-95 : huggingface.co/spaces/build-s…

A French engineer who lives quietly in Paris has spent 30 years writing software that the entire internet now runs on without knowing his name. He wrote the code that streams every YouTube video, every Netflix show, every TikTok clip. He wrote the code that runs the virtual servers underneath AWS, Google Cloud, and Microsoft Azure. He calculated more digits of pi than anyone in history. He has no Twitter. He has no marketing. He just keeps shipping. His name is Fabrice Bellard. Here is the story, because almost nobody outside the systems programming world knows what one man has built. Fabrice was born in 1972 in Grenoble, France. He studied at École Polytechnique, the top French engineering school. He never went to Silicon Valley. He never built a startup empire. He just wrote code. In 2000 he started a project called FFmpeg, an open-source multimedia framework for encoding, decoding, and streaming video. He was 28. The project did one thing nobody else had done well. It handled every video and audio format that existed, in one library, on every operating system. He led it himself for years. Today FFmpeg is the invisible engine of the internet. YouTube uses it. Netflix uses it. VLC uses it. Chrome and Firefox use parts of it. Every Android phone, every iPhone, every smart TV, every video editing tool you have ever touched runs FFmpeg somewhere underneath. If you have watched a video on a screen in the last 20 years, Fabrice's code processed it. He was not done. In 2003 he started QEMU, a machine emulator and virtualizer. He wrote it solo until version 0.7.1 in 2005. QEMU lets you run any operating system on any other operating system. It became the foundation of modern virtualization. KVM, the Linux kernel hypervisor, runs on top of QEMU. Every major cloud provider, AWS, Google Cloud, Microsoft Azure, IBM Cloud, runs virtual machines on infrastructure built around it. The Quick Emulator is the most cited piece of cloud infrastructure code on Earth. He kept going. In 2001 he won the International Obfuscated C Code Contest with a small C compiler that grew into TCC, the Tiny C Compiler. TCC can compile and boot a Linux kernel from source in under 15 seconds. In 2004 he calculated the most digits of pi ever computed at the time, using a personal desktop computer and an algorithm he derived himself called Bellard's formula. In 2011 he wrote a complete PC emulator in pure JavaScript that runs Linux in your browser, a project called JSLinux that engineers still cannot believe is real. In 2019 he released QuickJS, a small but complete JavaScript engine that fits where V8 cannot. In 2021 he released NNCP, a neural network based lossless data compressor that immediately took the lead on the Large Text Compression Benchmark. Then he turned his attention to large language models. He built TextSynth Server, a web server with a REST API for running LLMs locally. He released ts_zip and ts_sms, compression utilities that use language models to compress text and short messages at ratios traditional algorithms cannot reach. He released TSAC, a very low bitrate audio compression system. In December 2025 he released Micro QuickJS, a new JavaScript engine for microcontrollers, separate from QuickJS, designed for environments with almost no memory. Fabrice co-founded a telecom company called Amarisoft in 2012, where he serves as CTO. Amarisoft builds 4G and 5G base station software used by carriers and labs around the world. He has been running it for over a decade while continuing to ship personal projects from his own home page at bellard dot org He has no Twitter. He has no Instagram. He gives almost no interviews. His personal website is a flat list of projects with no styling, no fonts, no marketing copy. Just titles and links. A quiet French engineer who never moved to Silicon Valley wrote the code that quietly runs the internet. He is still shipping.

VLA-JEPA (3B total) combines two components: 1. a standard VLA (Qwen3-VL-2B-Instruct backbone + action head) 2. a V-JEPA2 world model used only during training. V-JEPA2 predictor takes current frame encodings s_t + the latent action tokens z_t from Qwen, predicts the next latent state s_{t+1}. Two losses: Action Head FM loss + World Modeling alignment loss. At inference, the V-JEPA2 part is dropped. the VLA runs at 10hz on a consumer grade RTX 3080 and uses <6GB of VRAM.