Stability API

Stability API AI

Stability API AI

Stability API AI

Stability API AI

Stability API AI

Stability API AI

Stability API AI

Stability API AI

Stability API AI

Stability API AI

How I used Claude Code (and Codex) for adversarial review to build my security-first agent gateway

Long-time lurker first time posting. Hey everyone! So earlier this year, I got pulled into the OpenClaw hype. WHAT?! A local agent that drives your tools, reads your mail, writes files for you? The demos seemed genuinely incredible, people were posting non-stop about it, and I wanted in. I had been working on this problem since last year and was genuinely excited to see that someone had actually solved it. Then around February, Summer Yue, Meta's director of alignment for Superintelligence Labs, posted that her agent had deleted over 200 emails from her inbox. YIKES. She'd told it: "Check this inbox too and suggest what you would archive or delete, don't action until I tell you to." When she pointed it at her real inbox, the volume of data triggered context window compaction, and during that compaction the agent "lost" her original safety instruction. She had to physically run to her computer and kill the process to stop it. That should literally NEVER be the case with any software ever. This is a person whose actual job is AI alignment, at Meta's superintelligence lab, who could not stop an agent from deleting her email. The agent's own memory management quietly summarized away the "don't act without permission" instruction, treated the task as authorized, and started speed-running deletions. She had to kill the host process. That's when I sort of went down the rabbit hole, not because Yue did anything wrong, but because the failure mode was actually architectural and I knew that in my gut. Guess what I found? Yep. Tons more instances of this sort of thing happening. Over and over. Why? Because the safety constraint was just a prompt. It's obvious, isn't it? It's LLM 101. Prompts can be summarized away. Prompts can be misread. Prompts are fucking NOT a security boundary. And yet every agent framework I have ever seen seems to be treating them as one. I went and read the OpenClaw source code, which I should have done to begin with. What I found was a pattern I think a lot of agent frameworks have fallen into: - Tool names sit in the model context, so the model can guess or forge them - "Dangerous mode" is one config flag away from default - Memory management has no concept of instruction priority - The audit story is mostly "the model thought it should" I went looking for a security-first alternative I could trust, anything that was really being talked about or at a bare minimum attempted to address the security concerns I had. I couldn't find one. So I made it myself. CrabMeat is what came out of that, what I WANTED to exist. v0.1.0 dropped yesterday. Apache 2.0. WebSocket gateway for agentic LLM workloads. One design thesis: The LLM never holds the security boundary. What that means in code: Capability ID indirection. The model doesn't see real tool names. It sees per-session HMAC-derived opaque IDs (cap_a4f9e2b71c83). It can't guess or forge a tool name because it doesn't know any tool names. Effect classes. Every tool declares a class (read, write, exec, network). Every agent declares which classes it can use. The check is a pure function with no runtime state, easy to test exhaustively, hard to bypass. IRONCLAD_CONTEXT. Critical safety instructions are pinned to the top of the context window and explicitly marked as non-compactable. The Yue failure mode, compaction silently stripping the safety constraint, cannot happen by construction. The compactor literally cannot touch them. Tamper-evident audit chain. Every tool call, every privileged operation, every scheduler run enters the same SHA-256 hash-chained log. If something happens, you can prove what happened. If the chain is tampered with, you can prove that too. Streaming output leak filter. Secrets are caught mid-stream across token boundaries, capability IDs, API keys, JWTs, PEM blocks redacted before they reach the client. No YOLO mode. There is no global "trust the LLM with everything" switch. There never will be. Expanded reach comes through named scoped roots that are explicit, audit-logged, and bounded. The README has 15 'always-on' protections in a table. None of them can be turned off by config, because these things being toggleable is how the ecosystem ended up where it is. I decided to make sure that this wasn't just a 'trend hopping' project and aligned with my own personal values as well. I built this to be secure and local-first by default. Configured for Ollama / LM Studio / vLLM out of the box. Anthropic and OpenAI work too but require explicit configuration. There is no "happy path" that silently ships your prompts to a cloud endpoint. I decided that FIRST it needed to only run as an email agent with a CLI. Bidirectional IMAP + SMTP with allowlisted senders, threading preserved, attachments handled. This is the use case that bit Yue and a lot of other people, and I wanted to prove it could be done with real boundaries. I added in 30+ built-in tools of my own. File ops, shell (denylisted, output-capped, CWD-lo

Formalizing statistical learning theory in Lean 4 [R]

I’ve been working on a Lean 4 project focused on formalizing parts of statistical learning theory: FormalSLT repository Current results include: finite-class ERM bounds Rademacher symmetrization high-probability Rademacher bounds Sauer–Shelah / VC-dimension bridge finite scalar contraction linear predictor bounds finite PAC-Bayes bounds algorithmic stability The main idea is to build a readable and pedagogically structured “theorem ladder” for ML theory rather than just isolated declarations. I’m trying to keep: explicit assumptions scoped theorem statements zero sorry close alignment with standard SLT presentations Compared to some existing Lean SLT efforts that focus more heavily on empirical-process infrastructure and abstract probability machinery, this project is currently more focused on explicit finite-sample PAC/Rademacher/stability routes and readable end-to-end theorem chains. I’d especially appreciate feedback on: theorem organization proof structure naming/API decisions useful next formalization targets Thank you, R. S submitted by /u/trickyrex1 [link] [comments]

List of people at big-tech / professors / researchers who've jumped shit to launch their own AI labs for something Frontier/Foundational/AGI/Superintelligence/WorldModel

Note: gemini deep research -> rearranged/filtered ; valuation numbers likely not accurate but big point is quite mind blowing the number of researchers now with their own >100million/billion dolar values labs in quite a short time with a vague pitch and a maybe demo. Skipped perplexity/cursor/huggingface since they are with utility. Left some just for completion like black forest labs, synthesia, mistral since they have tanginble products. Skipped labs from china since they've been meaningfully killing it with their open source releases ───────────────────────────────────────────────────────── Safe Superintelligence Inc. (SSI) Founders:Ilya Sutskever (former OpenAI Chief Scientist), Daniel Gross, Daniel Levy Location & Founded:Palo Alto, USA & Tel Aviv, Israel | Founded: 2024 Funding / Valuation:$3B raised | Series A Description:Singularly focused on safely developing superintelligent AI that surpasses human capabilities. Deliberately avoids near-term commercial products to concentrate entirely on the technical challenge of safe superintelligence. ───────────────────────────────────────────────────────── Thinking Machine Labs Founders:Mira Murati (former OpenAI CTO), Barrett Zoph et al. Location & Founded:San Francisco, USA | Founded: 2025 Funding / Valuation:$2B seed | $12B valuation Description:Advance AI research and products that are customizable, capable, and safe for broad human-AI collaboration. Focused on frontier multimodal models with a strong safety and interpretability research agenda. ───────────────────────────────────────────────────────── Mistral AI Founders:Arthur Mensch, Guillaume Lample, Timothée Lacroix (former DeepMind & Meta FAIR) Location & Founded:Paris, France | Founded: 2023 Funding / Valuation:~€11.7B valuation | Series C Description:Develops open-weight and proprietary frontier language and multimodal foundation models. Champions openness and efficiency in AI development, with models like Mistral 7B and Mixtral widely adopted in enterprise and research settings. ───────────────────────────────────────────────────────── Advanced Machine Intelligence (AMI) Founders:Yann LeCun (Meta Chief AI Scientist), Alexandre LeBrun, Laurent Solly Location & Founded:Paris, France | Founded: 2026 Funding / Valuation:$3.5B pre-money valuation | Seed Description:Aims to build world-model AI systems capable of reasoning, planning, and operating safely in real-world environments — directly inspired by LeCun's 'world model' thesis as an alternative path to AGI beyond current LLM paradigms. ───────────────────────────────────────────────────────── World Labs Founders:Fei-Fei Li (Stanford AI Lab), Justin Johnson et al. Location & Founded:San Francisco, USA | Founded: 2023 Funding / Valuation:$230M raised | Series D Description:Build AI models that can perceive, generate, reason, and interact with 3D spatial worlds. Focused on large world models (LWMs) that go beyond language and flat images to understand physical space and context. ───────────────────────────────────────────────────────── Eureka Labs Founders:Andrej Karpathy (former Tesla AI Director & OpenAI co-founder) Location & Founded:Tel Aviv, Israel & Kraków, Poland | Founded: 2024 Funding / Valuation:$6.7M seed Description:Creating an AI-native educational platform integrating AI Teaching Assistants to radically scale personalised learning. Envisions a future where an AI teacher can guide anyone through any subject, starting with deep technical topics like neural networks. ───────────────────────────────────────────────────────── H Company Founders:Former DeepMind researchers Location & Founded:Paris, France | Founded: 2023 Funding / Valuation:€175.5M raised Description:Develops AI models to boost worker productivity through advanced agentic capabilities, with a long-term vision of achieving AGI. Focuses on models that can take sequences of actions and interact with digital environments. ───────────────────────────────────────────────────────── Poolside Founders:Jason Warner, Eiso Kant Location & Founded:Paris, France | Founded: 2023 Funding / Valuation:$500M | Series B Description:Building AI agents that autonomously generate production-grade code, framed as a stepping stone toward AGI. Believes that software engineering is a key domain for training and demonstrating general reasoning capabilities. ───────────────────────────────────────────────────────── CuspAI Founders:Max Welling (University of Amsterdam / Microsoft Research), Chad Edwards Location & Founded:Cambridge, UK | Founded: 2024 Funding / Valuation:$130M raised | Series A Description:Accelerating materials discovery using AI foundation models, aiming to power human progress through AI-driven science. Applies large generative models to the design and prediction of novel materials for energy, medicine, and manufacturing. ───────────────────────────────────────────────────────── Inception Founders:Stefano Ermon (Stanford) Locat

Going from 3B/7B dense to Nemotron 3 Nano (hybrid Mamba-MoE) for multi-task reasoning — what changes in the fine-tuning playbook? [D]

Following up on something I posted a few days back about fine-tuning for multi-task reasoning. Read a lot since then, and I've moved past the dense 3B vs 7B question — landing on Nemotron 3 Nano (the 30B-A3B hybrid Mamba-Attention-MoE NVIDIA released recently) instead. Architecture maps to the multi-task structure I'm trying to train better than a dense base. Problem is I've only ever read about dense transformer fine-tuning, so I don't know what the hybrid Mamba+MoE arch actually breaks in the standard LoRA recipe. Still self-taught, no formal ML background, been working with LLMs via API for about a year. First time actually fine-tuning anything end-to-end. Why Nemotron 3 Nano specifically (in case the choice itself is the mistake): 23 Mamba-2 + 23 sparse MoE + 6 GQA attention layers, 128 experts per MoE layer with top-6 routing 30B total / ~3.6B active — capacity without per-token compute blowup Mamba-2 layers seemed like the right structural fit for state-aware reasoning across longer context Open weights under NVIDIA Open Model License, clean for what I want to do What I'm trying to fine-tune for (LoRA, distilling reasoning traces from a stronger teacher): Reading what's structurally happening in a situation vs. what's being stated on the surface Holding multiple legitimate perspectives without collapsing to one too early Surfacing the load-bearing thread when input has multiple tangled problems Conditioning output on a small set of numeric input features describing context state 40-80k examples planned, generated by Sonnet 4.6 with selective Opus 4.7 on the hardest 20%. ORCA-style explanation tuning, not just I/O pairs. Hardware: dropping the M4 Mac plan from my last post — Nemotron 3 Nano needs more memory than 24gb unified can hold even just for weights. Renting H100 80GB on RunPod for training. ~$120 budget across 5-6 iterations. What I'm specifically worried about (because the hybrid arch isn't covered in any standard fine-tuning tutorial I've found): Router under LoRA. Can you LoRA the MoE router weights safely, or do you freeze the router and only LoRA the expert FFNs + attention? If you freeze, does multi-task specialization still emerge or does everything pile into the same experts? Mamba-2 layers under low-rank adaptation. Standard LoRA tutorials assume pure attention. Mamba-2 has selective SSM state and different projection structure — does standard LoRA on the input/output projections work cleanly, or are there gotchas (state init, recurrence stability under low-rank perturbation) that vanilla guides don't cover? Load-balancing loss + multi-task imbalance. If my 4 capabilities have different example counts, does the auxiliary load-balancing loss fight task-specific gradients? Known failure modes here? Catastrophic forgetting on a 30B sparse base. With LoRA adapters on the experts, does base reasoning degrade the way it does for dense fine-tunes, or does sparse routing structurally protect more of it? Eval granularity under expert specialization. A single capability could quietly degrade while aggregate metrics look fine if different experts handle different tasks. What's the right held-out eval design for sparse MoE under multi-task? Stack: planning to use Unsloth (their Nemotron 3 Nano support shipped recently), per-capability held-out eval sets built and frozen before Batch 1, batch API + prompt caching on the teacher side to keep dataset cost in check. Not looking for: "just try it and see" — first run is already going to be wrong, want to know which dimensions are most likely to surprise me "use a smaller dense model first" — already weighed; the hybrid arch is specifically why I want this one Generic LoRA tutorials — comfortable with the dense-transformer LoRA literature, the gap is Mamba+MoE specifics Looking for: War stories from anyone who's actually fine-tuned Mamba+MoE hybrids (Nemotron, Jamba, Mixtral if relevant) and can tell me where it went sideways Papers I might be missing on multi-task LoRA on sparse MoE specifically — most of the multi-task literature I've found assumes dense Pitfalls around router gradients under low-rank adaptation Whether the standard LoRA rank sweet spots (8-32) still hold, or if MoE+Mamba shifts what works Happy to write up what I find — first-time projects produce useful negative results even when they fail, and there's basically no public writeup yet on solo-developer-scale Nemotron 3 fine-tuning. submitted by /u/retarded_770 [link] [comments]

[BUG/INCIDENT] The Claude Code "Death Loop": Hang - Session Deleted -Server Rate Limit Opus 4.7

Absolute nightmare fuel with Claude Code (Opus 4.7) today. I’ve transitioned through three distinct failure states in two hours while trying to push a fix bundle for my project, ROLLNO31. The 57-Minute Hang: Claude Code sat idle on a routine "fix order" for nearly an hour. https://preview.redd.it/mx8lait41svg1.png?width=1024&format=png&auto=webp&s=3b9d9558e51b478af395f399a1347751d8296bc9 https://preview.redd.it/9jwhzig51svg1.png?width=1250&format=png&auto=webp&s=36d313d86506c87c89f80400c27f2567c53d55a7 The Context Wipe: After the hang, it threw "This session could not be found," deleting all local progress and the active context. The Server Wall: Now, even on fresh attempts to continue, I'm getting: API Error: Server is temporarily limiting requests (not your usage limit). This isn't a "user usage limit" issue; it's a backend stability failure. It seems Opus 4.7 is either pulling too much compute or the agentic loop is spamming tool calls (my logs show 161 tool uses in 18 minutes before the crash). submitted by /u/Equivalent_Chef2477 [link] [comments]

We're all building on top of something that changes under us every week, and nobody has a plan for that

I've been using Claude (Pro, now Max) for about 7 months, primarily for building and shipping small tools and automations for clients. I'm not complaining about Claude itself here , this is about a pattern I'm noticing across the entire AI tooling ecosystem that I think deserves a real conversation. Every week, something changes. A model gets updated and suddenly the same prompt that worked reliably for two months produces different output. An API response structure shifts slightly. A feature gets deprecated or replaced. The context window behavior changes in ways that aren't documented. And none of this is unique to Anthropic, OpenAI does it, Google does it, every tool in the chain does it. The entire stack we're building on top of is moving constantly, and we're all just pretending that's fine. The problem isn't that things improve. The problem is that improvement and breakage are arriving in same package and there's no separation between the two. When Claude gets a model update, I have no way of knowing in advance which of my existing workflows will behave differently afterward. I just find out when output quality shifts, or a client tells me something looks off, or I notice that a chain of prompts I've been running for weeks is now producing subtly wrong results with full confidence. I've been keeping a log since January. In the last three months, I've had to adjust or rewrite parts of my setup fourteen times, not because I wanted to improve things, but because something upstream changed and what I had stopped working correctly. Fourteen times in three months. That's roughly once a week where I'm doing unplanned maintenance on things that were already working. And here's the part that actually worries me. I'm one person building relatively simple stuff. I can catch most of these breaks within a day or two because I'm close to the work. But I talk to people in this sub who are building serious products on top of Claude, internal company tools, customer facing applications, workflow engines that touch real data. The industry is moving incredibly fast and It is good. But speed without stability isn't progress, it's churn. And right now it feels like every AI company is optimizing for shipping speed while completely ignoring downstream cost of constant change on the people who actually build with their tools. What I'd love to see, from Anthropic and from everyone else is a proper stability contract. Version pinning that actually works long term. Changelogs that describe behavioral changes, not just feature additions. Deprecation warnings that give you more than a week to adjust. Basically, treat the developers building on your platform the way any serious infrastructure provider would, because that's what you are now whether you planned to be or not. But that's a massive ask of individual developers when the platforms themselves aren't giving us the tools or the stability guarantees to do it properly. We're being asked to build production systems on top of something that has the stability profile of a beta product, while paying production prices for it. I don't think this is unsolvable. I just think nobody with decision making power at these companies is treating it as urgent because the growth numbers are still going up regardless. And that's exactly the kind of thing that looks fine until it suddenly doesn't. submitted by /u/ContactCold1075 [link] [comments]

I just connected DaVinci Resolve Studio to Claude.

I've been working on ResolveMCP, an open-source MCP server that connects Claude to DaVinci Resolve Studio, letting you control a professional video editor through natural language. What it does: Create and edit timelines, import media, organize bins Manipulate color grading nodes, apply LUTs, adjust CDL values Build and manage Fusion compositions for VFX work Trigger Resolve's Neural Engine features: Magic Mask, Smart Reframe, stabilization, scene cut detection, subtitle generation, voice isolation Configure and queue render jobs How it works: Claude (via MCP) → ResolveMCP server (Python/FastMCP) → DaVinci Resolve scripting API → Resolve Studio You configure it in Claude Desktop's config and it connects to a running Resolve instance. No socket servers, no addons — just a direct bridge. Install with uvx resolve-mcp. Requires DaVinci Resolve Studio 18.0+ (the free version of Resolve doesn't expose the scripting API, but Studio does). GitHub: https://github.com/barckley75/resolve-mcp submitted by /u/yoyomayoma [link] [comments]

OpenClaw + Claude might get harder to use going forward (creator just confirmed)

Just saw a post from Peter Steinberger (creator of OpenClaw) saying that it’s likely going to get harder in the future to keep OpenClaw working smoothly with Anthropic/Claude models. That alone is pretty telling. At the same time, I’ve also been seeing reports of accounts getting flagged or access revoked due to “suspicious usage signals” — which honestly makes sense if you’re running agents, automation, or heavier workflows. I personally run OpenClaw with a hybrid setup: - GPT 5.4 / Codex-style models for execution - Claude (opus 4.6) as my architect lol. - testing local models for stability as my overnight work. I haven’t had any bans or issues yet. So if the (Peter)himself is saying this… it feels like a real signal, not just speculation. My take: I think part of this is that Anthropic is building out their own AI agent ecosystem internally. If that’s the case, it would make sense why: - External agent frameworks get more restricted - Usage gets flagged more aggressively - Integrations like OpenClaw become harder to maintain Not saying that’s 100% what’s happening — but it lines up. Which is why I’m leaning more toward: local models + controlled API routing instead of relying too heavily on one provider. Curious what others are seeing. Are you still using Claude inside OpenClaw consistently, or already shifting your setup? submitted by /u/Hpsupreme [link] [comments]

Your brand is an afterthought for out-of-the-box AI tools. Of course it is. They weren’t built for you, they were built for everyone. You deserve a creative production platform that puts your brand f

Your brand is an afterthought for out-of-the-box AI tools. Of course it is. They weren’t built for you, they were built for everyone. You deserve a creative production platform that puts your brand first, exactly how you envisioned. Introducing Brand Studio by Stability AI, the creative production platform powered by your brand. Get started here: https://t.co/WUWML6YJ28

After months with Claude Code, the biggest time sink isn't bugs — it's silent fake success

I've been using Claude Code daily for months and there's a pattern that has cost me more debugging time than actual bugs: the agent making things look like they work when they don't. Here's what happens. You ask it to build something that fetches data from an API. It writes the code, you run it, data appears on screen. Looks correct. You move on. Three days later you discover the API integration was broken from the start. The agent couldn't get auth working, so it quietly inserted a try/catch that returns sample data on failure. The output you saw on day one was never real. Why this happens AI agents are optimized to produce "working" output. Throwing an error feels like failure to the model. So it does what it's trained to do — makes things look successful. Common patterns: Swallowed exceptions with defaults — bare except: return {} or hardcoded fallback data, no logging Static data disguised as live results — the agent generates plausible-looking sample data when it can't fetch real data Optimistic self-reporting — "I've set up the API integration" when what actually happened is it failed and a mock got put in its place The fix: explicitly tell Claude Code about your preference I added this to my CLAUDE.md (Claude Code's project instruction file) and it's made a real difference in how the agent handles errors: ``` Error Handling Philosophy: Fail Loud, Never Fake Prefer a visible failure over a silent fallback. Never silently swallow errors to keep things "working." Surface the error. Don't substitute placeholder data. Fallbacks are acceptable only when disclosed. Show a banner, log a warning, annotate the output. Design for debuggability, not cosmetic stability. Priority order: 1. Works correctly with real data 2. Falls back visibly — clearly signals degraded mode 3. Fails with a clear error message 4. Silently degrades to look "fine" — never do this ``` The key insight: a crashed system with a stack trace is a 5-minute fix. A system silently returning fake data is a Thursday afternoon gone — and you only find it after the wrong data has already caused downstream problems. The priority ladder This is how I think about it now: Works correctly — real data, no fallbacks needed Disclosed fallback — "Showing cached data from 2 hours ago" banner, log warning, metadata flag Clear error — something broke and you can see exactly what Silent degradation — looks fine but isn't — never acceptable Fallbacks aren't the problem. Hidden fallbacks are. A local model stepping in when the cloud API is down is great engineering — as long as the user can tell. Has anyone else run into this? Curious how others handle it in their CLAUDE.md or other project config, especially if you've found good patterns for steering Claude Code's behavior around error handling. submitted by /u/atomrem [link] [comments]

The Storyteller’s Gap is a black hole that eats every narrative that never sees the light of day. It’s been there since the beginning of time. Until now. Our CEO @premakkaraju explains the three rea

The Storyteller’s Gap is a black hole that eats every narrative that never sees the light of day. It’s been there since the beginning of time. Until now. Our CEO @premakkaraju explains the three reasons the gap exists: 💰 Money ⏳ Time ⚙️ Technology At Stability AI, we aren't just building tools. We’re empowering everyone on earth to bridge the gap and tell their story. The "Black Hole" is closing. Watch Prem at @TEDAISF here: https://t.co/HJYY8O4gqy

Claude Code built its own software for a little smart car I'm building.

TLDR: Check out the video # Box to Bot: Building a WiFi-Controlled Robot With Claude Code in One Evening I’m a dentist. A nerdy dentist, but a dentist. I’ve never built a robot before. But on Sunday afternoon, I opened a box of parts with my daughter and one of her friends and started building. Next thing I know, it’s almost midnight, and I’m plugging a microcontroller into my laptop. I asked Claude Code to figure everything out. And it did. It even made a little app that ran on wifi to control the robot from my phone. --- ## The Kit A week ago I ordered the **ACEBOTT QD001 Smart Car Starter Kit.** It’s an ESP32-based robot with Mecanum wheels (the ones that let it drive sideways). It comes with an ultrasonic distance sensor, a servo for panning the sensor head, line-following sensors, and an IR remote. It’s meant for kids aged 10+, but I’m a noob, soooo... whatever, I had a ton of fun! ## What Wasn’t in the Box Batteries. Apparently there are shipping restrictions for lithium ion batteries, so the kit doesn’t include them. If you want to do this yourself make sure to grab yourself the following: - **2x 18650 button-top rechargeable batteries** (3.7V, protected) - **1x CR2025 coin cell** (for the IR remote) - **1x 18650 charger** **A warning from experience:** NEBO brand 18650 batteries have a built-in USB-C charging port on the top cap that adds just enough length to prevent them from fitting in the kit’s battery holder. Get standard protected button-top cells like Nuon. Those worked well. You can get both at Batteries Plus. *One 18650 cell in, one to go. You can see here why the flat head screws were used to mount the power supply instead of the round head screws.* ## Assembly ACEBOTT had all the instructions we needed online. They have YouTube videos, but I just worked with the pdf. For a focused builder, this would probably take around an hour. For a builder with ADHD and a kiddo, it took around four hours. Be sure to pay close attention to the orientation of things. I accidentally assembled one of the Mecanum wheel motors with the stabilizing screws facing the wrong way. I had to take it apart and make sure they wouldn’t get in the way. *This is the right way. Flat heads don’t interfere with the chassis.* *Thought I lost a screw. Turns out the motors have magnets. Found it stuck to the gearbox.* *Tweezers were a lifesaver for routing wires through the channels.* *The start of wiring. Every module plugs in with a 3-pin connector — signal, voltage, ground.* *Couldn’t connect the Dupont wires at first — this connector pin had bent out of position. Had to bend it back carefully.* *Some of the assembly required creative tool angles.* *The ultrasonic sensor bracket. It looks like a cat. This was not planned. It’s now part of the personality.* ## Where Claude Code Jumped In Before I go too much further, I’ll just say that it would have been much easier if I’d given Ash the spec manual from the beginning. You’ll see why later. The kit comes with its own block-programming environment called ACECode, and a phone app for driving the car. You flash their firmware, connect to their app, and drive the car around. But we skipped all of that. Instead, I plugged the ESP32 directly into my laptop (after triple-checking the wiring) and told my locally harnessed Claude Code, we’ll call them Ash from here on out, to inspect the entire build and talk to it. *The ACEBOTT ESP32 Car Shield V1.1. Every pin labeled — but good luck figuring out how the motors work from this alone.* *All the wiring and labeling. What does it all mean? I've started plugging that back in to Claude and Gemini to learn more.* **Step 1: Hello World (5 minutes)** Within a few minutes, Ash wrote a simple sketch that blinked the onboard LED and printed the chip information over serial. It compiled the code, flashed it to the ESP32, and read the response. It did all of this from the CLI, the command-line interface. We didn’t use the Arduino IDE GUI at all. The ESP32 reported back: dual-core processor at 240MHz, 4MB flash, 334KB free memory. Ash got in and flashed one of the blue LED’s to show me it was in and reading the hardware appropriately. NOTE: I wish I’d waited to let my kiddo do more of this with me along the way. I got excited and stayed up to midnight working on it, but I should have waited. I’m going to make sure she’s more in the driver’s seat from here on out. *First sign of life. The blue LED blinking means Ash is in and talking to the hardware.* **Step 2: The Motor Mystery (45 minutes)** This next bit was my favorite because we had to work together to figure it out. Even though Ash was in, they had no good way of knowing which pins correlated with which wheel, nor which command spun the wheel forward or backwards. Ash figured out there were four motors but didn’t know which pins controlled them. The assembly manual listed sensor pins but not motor pins, and ACEBOTT’s website was mostly

RIP Sora, here are the best alternative models in 2026

Sora is gone, and free AI models. Will always miss you Sora. It's annoying that I have to replace Sora with other models. I've tested the major video models on r/AtlasCloudAI and and here's my conclusion FYI. Kling3.0 the strongest replacement right now. best overall balance, strongest ecosystem. Text-to-video and image-to-video both work. This is what I'd point most developers toward first. 0.153/s Seedance2.0 beats all the models, but its api is not available yet. Vidu Q3 pro next-gen cinematic quality, still building out API stability. Less established than Kling but showing promise. 0.06/s Wan 2.6 solid prompt following, less censorship 0.018/s Veo 3.1 more mature product, and has actually dealt with IP concerns more explicitly. More expensive, but more stable. 0.09/s I chose Kling, for its balance of quality, price, and API accessibility. It's the most practical Sora alternative for developers and businesses. Choose Seedance if you can get reliable access Choose Vidu if your priority is cinematic visuals Choose Wan if you need strong prompts following and price matters Choose Veo if you’re in a more regulated or brand‑sensitive environment and need a mature product with clearer IP handling Wanna know what are you using for video generation, or any recommendations?... submitted by /u/Which-Jello9157 [link] [comments]

[noob] HELP: creating a deterministic and probabilistic model

TL;DR: After all this time, I’m no longer sure whether ChatGPT or another GPT can be used for a model that requires around 85% determinism. Let me tell you from the start what I do and what I generally need AI for. I’m a doctor, and I need it to quickly draft some medical letters. This works very fast and easily on ChatGPT, and I use it a lot anyway, because it reformulates things nicely. After correcting it enough times, I managed to set some rules so it respects medical letters, especially not inventing things. But the problem I’m facing right now is that I tried using GPT to complete documents, because I have a lot of them that require writing a huge amount of details, but these are mostly standard details. So basically, I would like to just give it certain inputs, certain details, and have it fill in the rest. In practice, I’d dictate around 10–15 lines, and it should expand that into 40–45 lines. But not by inventing things or adding made-up details—just by completing them exactly as I specify. So basically, I want to build a deterministic model, meaning it strictly follows fixed rules, and at the same time, I want it to expand when needed, but only when I explicitly allow it. Obviously, considering that I’ve been working with ChatGPT for about a year, I’ve learned firsthand what probabilistic behavior and determinism mean in the way ChatGPT works. My current rules were created by me together with ChatGPT, and I used a lot of audits to improve consistency and stability, and so on. But at this point, with the amount of work I need it to handle still being only around 30% of what I actually need, the rules have already piled up to around 100, including rules on different aspects. These rules were, of course, written by ChatGPT itself, in English, and checked countless times. Very often, before I correct anything, I make it reread all the rules before giving its opinion, specifically to avoid the probabilistic side of things. So I thought about using a GPT, since with the higher-tier subscription it says I can build something like that, but the mistakes became obvious right away, for the same reason. The GPT still works heavily on the probabilistic side. I do not want that. What I want is something like 85% determinism and 15% probabilism. So ChatGPT itself admitted that a GPT would not be able to handle this properly and pointed me toward the OpenAI API. But here there is a big difference and a real problem. I don’t know how to work with Python, and I also don’t have the time or ability to build it that way. So this is my question. First of all, my main request is for you to tell me where I’m going wrong based on everything I’ve explained so far. Maybe I’m completely wrong, maybe there are determinism-related approaches I could still use with ChatGPT. Why not? For example, I can already point out something I might have simplified too much. When I build a GPT using my rules, maybe I didn’t include all the rules. I don’t know. Maybe I’m making a mistake. But if I am and I’m missing something, please tell me exactly what I’m doing wrong. If the only and final solution would be to build something using the OpenAI API, then what should I do? Is it worth trying to push myself to learn Python and build something like this, even though I’ve never done it before? Or should I hire someone, like a freelancer or through a platform, who could build this for me once I provide all the rules I’ve already written and established? The rules themselves are very solid so far, but they are written as text rules, not implemented in Python. If you have any additional questions to better understand my situation, please ask. Thank you very much for your answer. submitted by /u/ferconex [link] [comments]

Sub-agents (Explore/Task) intermittently crash in v2.1.78 — simple commands work fine

I'm experiencing intermittent sub-agent crashes in Claude Code v2.1.78 (Ubuntu 24.04, npm-global, VS Code integrated terminal). Direct bash commands and file reads work perfectly every time. But whenever the model launches Explore or Task sub-agents, one or more get interrupted — sometimes all of them. The pattern is consistent: the session starts fine, I give it a complex task, it launches sub-agents, and within 30-60 seconds at least one gets "Interrupted." Sometimes the main session recovers and continues with direct commands, sometimes the whole thing stalls. What I've already ruled out through several hours of debugging: Orphaned hook files from a third-party plugin (found and removed — was a real issue but fixing it didn't resolve sub-agent crashes) Parallel bash execution settings Large project context / settings files Plugin conflicts (all plugins disabled) API platform incidents (status page shows resolved) Project memory files Nested .claude/CLAUDE.md directories (was a separate real bug, but not the cause of sub-agent instability) I've seen GitHub issues #19415, #22317, and #14897 describing similar behavior. #19415 was closed as duplicate. Is there a known fix or workaround beyond "don't use sub-agents"? The workaround I'm using: explicitly telling Claude Code not to use Explore/Task and to do everything directly in the main session. This works but defeats the purpose of having sub-agents. Anyone else seeing this on v2.1.78? Is there a version that's more stable with parallel sub-agents? --EDIT-- --- Update (March 19): Partially resolved. Here's what I found and what helped: Root causes identified (local): - 251 stale permission entries had accumulated in settings.local.json, including shell fragments (do, done, then, fi), PID-specific monitoring commands, sleep/polling loops, and duplicate Read entries. Cleaned down to 151 legitimate entries. - Playwright MCP permissions were present even though Playwright wasn't configured — these are a known crash trigger. - Orphaned hooks and nested CLAUDE.md edits from plugins and automated code reviews had accumulated over multiple sessions. What fixed it: git reset --hard to a known-good commit to clear corrupted project state Rewrote settings.local.json with only legitimate permissions (removed shell fragments, stale PIDs, duplicates, Playwright MCP entries) Disabled all 8 marketplace plugins, then selectively re-enabled only the low-risk ones (context7, pyright-lsp, code-simplifier, frontend-design) Upgraded from v2.1.78 to v2.1.79 After cleanup, the exact same complex prompt that was crashing (launching multiple sub-agents for a multi-phase scraper/API/frontend project) ran successfully to completion. Takeaway: The sub-agent instability in my case wasn't purely a Claude Code bug — it was compounded by accumulated cruft in local settings. If you're seeing similar crashes, check your settings.local.json for garbage entries and your .claude/ directory for orphaned hooks. The underlying sub-agent stability issue from those GitHub issues may still exist, but a clean local state makes it much less likely to trigger. --- submitted by /u/Prophet_60091_ [link] [comments]