Pi

Pi AI

Pi AI

Pi AI

Pi AI

Pi AI

Pi AI

Pi AI

Pi AI

Pi AI

Pi AI

You can't tell when your self-hosted AI is broken. That's the part nobody talks about.

When Jellyfin stops playing, you see the error. When Pi-hole fails, websites stop loading. When your NAS drive dies, you hear the click of death 😆. Every self-hosted service tells you when it's broken. LLMs don't. They just generate slightly wrong answers with perfect confidence. You could have a hallucinating model running for a week and never notice, because every response looks right unless you know enough to verify it. I found this out the hard way. Hermes Agent runs tasks for me 24/7. One day I noticed it was writing nonsense. Full sentences, correct grammar, completely wrong information. No error. No crash. Just quietly producing garbage for who knows how long. How do you monitor something that fails successfully? submitted by /u/sarox-dev [link] [comments]

I built mcpgen — turn any OpenAPI spec into a working MCP server in one command.

pip install mcpgen-cli mcpgen https://petstore3.swagger.io/api/v3/openapi.json Generates a complete Python MCP server you own. Not a proxy — actual source code you can read, modify, and deploy anywhere. No runtime dependency on mcpgen. Supports OpenAPI 3.x (JSON/YAML/URL) and Postman collections. Auth auto-detected. Prints your Claude Desktop config block at the end. GitHub: https://github.com/JnanaSrota/mcpgen PyPI: https://pypi.org/project/mcpgen-cli/ submitted by /u/Pale-Sugar-1330 [link] [comments]

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]

[R] I built a cognitive architecture that learns like a brain — no backprop, no GPU, no forgetting

Most AI systems are built on three assumptions: you need backpropagation, you need GPUs, and you need to carefully prevent catastrophic forgetting. I wanted to see what happens if you throw all three out. RAVANA is a research prototype that: Learns through prediction errors — like Friston's free energy principle, the system feels "pressure" when predictions fail and self-organizes to reduce it Never forgets — a biologically-inspired sleep cycle (SWS for consolidation + REM for creative recombination) eliminated catastrophic forgetting entirely in our tests Runs on CPU — pure NumPy, works on a laptop Has emotions — a 3D Valence-Arousal-Dominance engine modulates how the system learns and infers Learns continuously from the web — curiosity-driven exploration, no retraining needed Supports multi-user beliefs — a BeliefStore tracks who believes what and merges across users I'm at the stage where I need community feedback, discussion, and contributors. The codebase is substantial (~25k lines across 3 packages) with 1250+ tests and published on PyPI. This is not a product — it's a research project exploring whether pressure-driven self-organization can work as a genuine alternative to gradient-based learning. Would love to hear thoughts from this community. Code: https://codeberg.org/oxiverse/ravana | https://github.com/oxiverse-ecosystem/ravana submitted by /u/ItxLikhith [link] [comments]

Claude, are you ragebaiting me? Do step 1. Do step 2. Ok now just wait. What next? Just keep waiting. Installed? Great, now wait again.

and I did wait, and I did not take the bait. submitted by /u/eli_arad [link] [comments]

I built notmemory — auditable, reversible memory for AI agents. v0.1.0 on PyPI. Looking for contributors.

After too many debugging sessions where I had no idea what my agent remembered or why it made a decision — I got frustrated and built something. notmemory is an open-source Python SDK that gives AI agents auditable, reversible memory. Not magic. Just a tamper-proof record of what your agent knew, when it knew it, and the ability to undo the moment it got something wrong. The problem I kept hitting My agent would do something wrong. I'd dig into it. I could see what was currently in memory — but not what it believed at step 47 when it made the bad decision three days ago. Every debugging session felt like archaeology. I got tired of it. What notmemory does Cryptographic audit trail Every write is SHA-256 hash-chained. Like Git commits, but for memory. You always know what changed, when, and in what order. Git-like rollback await memory.rollback(transaction_id) One line. Bad write gone. Hash chain stays valid. GDPR tombstoning await memory.forget(bank_id) Proven deletion with a forensic trail. Not just "deleted from index." Conflict detection Catches duplicate or contradicting beliefs before they cause problems. Health score 0–100. Confidence decay c(t) = c₀ · 2^(−t/30) — stale memories lose weight automatically. No more old beliefs quietly poisoning recall. LangGraph drop-in from notmemory.adapters.langchain import NotMemoryCheckpointer checkpointer = NotMemoryCheckpointer() graph = builder.compile(checkpointer=checkpointer) # that's it — every checkpoint is now auditable MCP server Works with Claude Desktop, Cursor, Windsurf out of the box. Mem0 + SuperMemory sidecars SQLite is the source of truth. Semantic search layers on top. If the sidecar goes down, your data is fine. Multi-agent sync READ / WRITE / ADMIN permissions per memory bank per agent. Install pip install notmemory # with LangChain / LangGraph pip install "notmemory[langchain]" # with MCP pip install "notmemory[mcp]" Quick example import asyncio from notmemory import AgentMemory async def main(): async with AgentMemory() as memory: # store something entry = await memory.retain( bank_id="facts", content={"fact": "Paris is the capital of France"}, source="user", ) # search it result = await memory.recall(bank_id="facts", query="Paris") # undo it await memory.rollback(entry.transaction_id) # delete it with proof await memory.forget("facts") asyncio.run(main()) Where it is today (v0.1.0) 113 tests passing across Python 3.11, 3.12, 3.13 SQLite + FTS5 full-text search LangChain, LangGraph, Mem0, SuperMemory, MCP adapters Confidence decay, Git backup, multi-agent sync MIT license, CI/CD, full README What's coming in v0.2.0 Feature What it does memory.state_at(timestamp) Read memory as it was at any point in time Crypto-shredding Encrypt-on-write + key destruction for real GDPR compliance memory.export_state() Clean JSON snapshot of any memory bank memory.diff(from_ts, to_ts) Human-readable before/after between two timestamps Belief lineage Which downstream writes were caused by a bad early assumption Honest take This is v0.1.0. The core is solid but it's early. SQLite only for now — Postgres is planned. The adapters are sync-layer wrappers, not full replacements for Mem0 or SuperMemory. If you're running a hobby project with one agent — you probably don't need this yet. If you're running multiple long-lived agents, working in a regulated industry, or have already had a production incident you couldn't properly debug — this is for you. Looking for contributors The codebase is around 2000 lines. Every adapter follows the same BaseAdapter pattern so it's easy to get oriented. Good first issues are tagged on GitHub. Things I'd love help with: Postgres backend Crypto-shredding implementation memory.state_at(timestamp) Dashboard UI (FastAPI + SSE already in optional deps) Docs and examples Feedback Would love to hear from: Anyone running agents in healthcare / finance / legal Fleet operators with 5+ concurrent agents Anyone who's already built their own memory audit system and had to solve things I haven't thought of yet Brutal feedback welcome. That's the only way this gets better. GitHub: https://github.com/notmemory/notmemory PyPI: https://pypi.org/project/notmemory/ submitted by /u/imsuryya [link] [comments]

I feel like I’m alone. Current Anthropic models are NOT good for me, and it’s making me sad.

I can’t wait for DeepSWE to include Fable 5 in the benchmark so people can understand that Mythos is mostly hype. In the official benchmark, Opus 4.8 was supposed to be better at programming than 5.5 (SWE-bench Pro), but in one real benchmark where the model can’t cheat (I’m looking at you, Claude), it was more than 10% worse than 5.5. And once again, that was supposed to be the most powerful model in the world, completely beating 5.5 in most tasks. Like dude, shut up. Fable 5 is probably barely better than 5.5, or maybe just equal, and that’s two versions more recent than 5.5. It’s pissing me off. It’s so much more expensive and barely better, and the only reason Anthropic is even thinking of doing this kind of thing is because the AI community is full of people who don’t understand what makes a model good. From my use cases, Opus 4.8 was literally one of the worst models for me, and the most expensive. When I asked it to init a dir with Rust and Mold, it made a mistake with Mold, then told me Mold was generally broken and that it was not possible to fix, then just continued without it. When I asked 5.5 to do the exact same task, it made the exact same mistake, then fixed the path and used it. The hype around Anthropic is pissing me off so much. The models are lazy and reckless. The tools are badly implemented. Like why the fuck would you use Ink for the TUI? I don’t know, it just doesn’t feel like a lot of thought was given. People think that just because the model can create a better-looking app, it means the model is better. Like what the fuck? Yeah, congratulations on your good interface, but for me, using it in sensitive environments, I can’t fucking trust any Claude model. I keep seeing people with OpenClaw and Claude Code and whatever, launching agents to do all their work, and I’m like, great, really great, and I can’t fucking trust it to init my project. And for anyone saying it’s user error, I bought the Max plan, used the most powerful model for basically a year, and my results were consistent. I wasn’t just saying “init my dir.” I was doing prompt engineering, custom tools, when Anthropic was allowing it, kinda, with Pi coding agent, then custom instructions. I’ve tried everything, and the only thing all Claude models are good for is telling me to go to sleep. And guess what, I have alarms for that. submitted by /u/askmdev [link] [comments]

Automated Pigeon Deterrent Water Turret built with Claude AI

Hello Air Claude, I built last week a robotics project, 100% based on Claude AI. Claude basically told me what to buy, how to assemble it, and coded everything. The goal was to build a Pigeon Deterrent Water Turret. Claude made me buy a Raspberry Pi 5 + AI HAT + Tilt Pan HAT + Camera, some servo motors, and a watergun. Claude then helped me creating the schematics, and coded everything. I wrote zero line of code for this project. The hardest part was to actually think about the specs of the project, and to wait for the hardware to be shipped (well, it was also hard to add the waterpump on the servo motors, as shown by the electrical tape that holds everything together). The method I used is: - have a lot of iterations on the specs, to help Claude understanding exactly what I had in mind; - tell Claude to memorize everything when I had to wait for hardware to get shipped; - install Claude code directly on the Raspberry so that it could actually get access to camera and motors and program everything easily (working through SSH was not as efficient). Demo of the bot hunting me Demo of a pigeon repelled by the bot Here is a list of the things used to build the project (no referral links): - Raspberry Pi 5 AI kit https://www.kubii.com/en/kits-nano-ordinateurs/5081-kit-raspberry-pi-5-edition-intelligence-artificielle-3272496325944.html - electrical watergun (to get a pump + battery) https://www.amazon.fr/dp/B0CGRCQ6VR - optical relay https://www.kubii.com/en/modules-relais/1969-module-1-relais-avec-couplage-optique-5v-kubii-3272496008250.html - Pan-Tilt Hat WaveShare https://www.kubii.com/en/objectifs-supports/2790-pan-tilt-hat-pour-raspberry-pi-3272496299924.html - Camera https://www.kubii.com/en/cameras-capteurs/3878-module-camera-v3-raspberry-pi-3272496313699.html - Wires https://www.kubii.com/en/kits-de-composants/1764-kit-de-composants-electroniques-pour-raspberry-pi-kubii-3272496006232.html Source code: https://github.com/tarraschk/GardenGuardian I have been really impressed by Claude's ability to even draw electrical schematics that i would understand. Next step would be building a waterproof case, and also adding a solar panel with a battery. Let's see if Claude can also help me making these improvements! submitted by /u/tarraschk [link] [comments]

Used Claude Code to finally crack wireless DualSense adaptive triggers on Linux after weeks of fighting it

Background: I've got a Raspberry Pi Pico dongle that bridges a DualSense over Bluetooth, and the thing I couldn't get was the adaptive triggers (not just rumble) working wirelessly on Linux. That only ever worked wired. Got it done tonight, and a big chunk of the debugging happened with Claude Code. What it was actually good for: The breakthrough was diffing two PROTON_LOG HID traces, one from a real DS5 plugged in directly and one from the dongle, both about 15MB, to find the single thing the game's parser rejected. The dongle was answering one feature report with zeros instead of the controller's real cached firmware/calibration data, and the game retried it 156 times then gave up. I would not have spotted that by eye. It also caught that my HID descriptor was 32 bytes longer than a real DS5 because I'd left some custom config reports declared. The part I didn't expect was how useful it was for arguing with me. I burned a couple hours convinced Heroic was broken, first blaming OpenRGB, then a "device collision," and it kept dragging me back to what the logs actually said. The real answer was boring: the games I was testing (Ghostrunner, Control) are XInput-only and physically can't do adaptive triggers. Tested Cyberpunk on GOG instead and it worked. I'm not going to pretend it was one-shot magic. There was a lot of back and forth, it sent me down a couple of wrong paths too, and I had to keep it honest. But for the log grinding and the "your own evidence contradicts that" moments, it saved me days. Repo if anyone wants it: DS5Dongle-OLED-Edition submitted by /u/marcys_out [link] [comments]

Shipped a production iOS app with Claude as a non-technical PM in 2.5 months. What I learned, what worked, what broke, and the moment Claude said "trust me bro, it's fixed"

I'm a product manager with 10+ years of experience and zero coding background. I just shipped my first iOS app in 2.5 months (20-25 hours a week) using Claude as my coding partner. Posting here to share my learnings, my workflow (would love feedback!) and a hilarious hallucination. Would love to hear your funny hallucinations. When I asked Claude to estimate the total build time at the start, it quoted 8 months. I had the first complete local build running in 2 weeks and felt invincible. Then I spent the next 2 months doing the other 80% of the work, which was honestly a slog. What I learned about working with Claude on a real production codebase: Spec before you vibe I used the plaid.build skill (no affiliation, just a fan) to put together a product vision doc, roadmap, and requirements doc before I wrote a line of code. It forced me to make architecture decisions upfront, sparring with Claude, instead of discovering halfway through that my data model was wrong. This is probably the highest-leverage thing you can do. Non-technical folks, it will help you make architecture choices and write out tech specs. Technical folks, it will help you define your go to market plan and tightly scope your MVP. Two days spent with this skill including reading the docs and providing feedback saved me probably two weeks of "Claude why is this broken" debugging on the wrong foundation. I also tried asking Claudes built in skills like /architecture and /design-system but the feedback they gave me, while good, blew up my requirements and was way more than what I needed for an MVP. If I'd listened to their advice it would have taken me probably 4-5 months to launch on the app store. Do spikes Claude recommends any unfamiliar provider? Do a 1-2 hour spike to make sure AI isn't hallucinating and the provider actually meets your needs. Doing this would have saved me a very painful week. Once I gave up on the first provider Claude recommended and did spikes, I was able to choose and implement a working solution in less time that I spent arguing with the original provider. Where Claude carried me Anything well-documented and pattern-heavy: Clerk auth setup, basic CRUD, scaffolding screens, file structure conventions, copy generation. Ask Claude for it's experience and confidence level with each piece. I set up Clerk in 3 hours feeling like a genius. I got a usable settings page in 15 minutes. This is the part of the workflow that genuinely feels like magic, and it's also the part you should expect to work. Where Claude broke down Front-end fiddling. I spent 3 hours debugging a single X close button before giving up with "good enough." My designer friends will cry when they see it it's honestly bad. Claude can scaffold a UI but precision pixel-level interaction work is where it ran out of road for me. Front end development is generally painful and AI still hasn't cracked it. Anything involving a third-party provider where you have to do a lot of configuration in their portal. I spent a full week getting RevenueCat integrated correctly, and apparently RevenueCat is one of the simpler payment integrations. I now understand every developer who has ever complained about Stripe. Maybe an AI browser where it can see your browser and do things for you would have helped, but I don't trust any AI enough yet for this. Real-time video with Picture in Picture support. Claude's first-pick video provider couldn't actually do PiP properly, despite Claude being highly confident it could. I spent several days trying to make it work before reverting to traditional dev practice: 1-2 hour spikes on the next 3 contenders, picked a winner based on actual results, implemented working PiP faster than my original failed attempt. Lesson learned: when Claude is stuck in a loop trying to make X work, swap X out and try alternatives rather than pushing through. Or better yet, do spikes first before locking in your architecture choices. The "trust me bro, it's fixed" moment After multiple failed attempts on a single stubborn bug - HOURS - I was frustrated, Claude was frustrated. After 2 hours Claude basically started saying "no need to test this again, trust me bro its fixed" lol!. For my next app, I'm spending time early on to set up some automated visual regression testing so Claude can't hallucinate as much. Code review process After code was ready, I would do manual testing and ask Claude to fix bugs. Then I would: Run ALL THREE of these built-in skills sequentially against the uncommitted changes. Do not skip any — each one catches different issues: 1. \/security-review\ — Identify security vulnerabilities in the new code. Fix any issues found.`` 2. \/simplify\ — Check for unnecessary complexity, duplication, or over-engineering. Fix any issues found.`` 3. \/review\ — General code review for quality, correctness, and best practices. Fix any issues found.`` Then commit push pr When I was planning out my PR review process, Claude told

I made a calendar/dashboard on a raspberry pi to help my wife and myself manage our schedules. It displays on a 77 inch OLED. I made a companion app for her phone that uses Apple Intelligence and Qwen installed on the Pi to clean up entries. She travels ~%50 of the year.

All the calendar entries and stuff about work are fabricated in the screenshots. This was kind of annoying to do but I wanted to share anyway so I put the effort in. It's actually prettier on the OLED than the screenshots do it justice. (e.g., the flowers on the right in dark mode look almost like they're suspended in ether that's a little lost here.) I did this last time: https://www.reddit.com/r/ClaudeAI/comments/1tbjp08/sonos_quit_supporting_their_mac_app_and_my_wife/ I am writing this top portion without Claude. As a quick reminder I am an IP lawyer. I am not a coder/developer. But I'm having fun making things with Claude/Claude Code for myself and my wife to use. (And also some work stuff that's not very fun but does a lot for me as a an IP/Trademark attorney.) Top line summary: built a calendar/dashboard on a Raspberry Pi for my 77-inch OLED to help organize kids/wife's travel schedule/my schedule, and built a companion iOS app mostly trying to make something pretty so my wife will actually want to use it. I'm not selling anything. I am posting a hobby project mostly just to show what I did and get feedback. The user base is 2. It might expand to include my kids. My wife has terrible eyesight so part of this is driven by her eyes. At home the "Almanac" displays on a 77-inch OLED in our bedroom, which has a lofted office. My wife is a neuroscientist. She travels ~50%. "Hey, while you're awake [5am], could you tell me what the weather is in [city 1] and [city 2]?" "...what are the dates you're going to be there?" "[City 1] today, [City 2] I'm not sure. Could you open the calendar for me while I pack?" I also routinely shout calendar entries at Siri, and Siri is not good at understanding my deep voice, so I have another AI, Qwen, on the Pi that audits entries. (E.g., Coffee with chris Evan's becomes Coffee with Chris Evans.) My wife wanted to take pictures of text and turn them into calendar entries. The phone extracts the event with Apple Intelligence and writes it straight to the calendar. The Pi's Qwen pass — the same one that audits my Siri entries — then catches OCR typos and miscapitalized names. I might at some point use Haiku but the idea of something that runs locally on a Pi without tokens was appealing (and for the use case I think Haiku might be using a small atomic weapon to kill a mosquito). If you tap the weather in the last panel of Bouquet it will give you granular weather if you're close enough in time for it to populate for that day and give photography recommendations. (e.g., golden hour) The photography stuff was just kind of me being gratuitous though. I was never grumpy about the early-morning wake-up and help-with-logistics chats. (I'm still more than happy to wake up before dawn, have a coffee, and talk things through.) But I figured out that the same questions came up a lot and went to work trying to put the answers in one place. My wife is basically blind though. There are subscription services that kind of do what I want, and devices you can buy that are basically just cheap iPads that can't do very much. I wasn't interested in either, and I know my wife wouldn't use them because they're not pretty to look at. My first thought was that if my smart TV could support a bunch of disorganized garbage apps I'll never open, then clearly they would love to host my indie app for two people in some fashion. That was stupid on my part. Smart TVs don't anticipate people coding for just their home and mostly want to broker deals between Netflix and Prime for who gets top billing on their OS which ends up looking like something an ADHD squirrel with a subscription addiction would make. So I bought a Raspberry Pi and went to work making a kiosk with our shared calendar that also pulls in other calendars we both use. It all pipes into the Pi and turns on automatically in the morning on our 77-inch OLED. The companion app uses a lot of the same things the dash does, but also ties in Apple Intelligence to streamline calendar entries from scanning photos. Building this, I knew my wife would never use it unless it was pretty, and this is one of those cases where the form is the function. I made sure it's something she wanted to use. Unexpected tool that proved useful: the Pi's dashboard server only listens on localhost — nothing's port-forwarded or exposed to the internet — and Tailscale republishes it on my private tailnet over HTTPS, so the phone app just points at one stable hostname and reaches it from anywhere. That means the wall and the phone read the same backend whether I'm home or not, and the only devices that can even see it are the ones signed into my tailnet. Here's Claude's take on it: How it works: the shared calendar lives in iCloud, and the Raspberry Pi is the brain sitting in front of it. The Pi pulls events from iCloud over CalDAV, folds in weather, and does two jobs at once — it renders the wall "Almanac" in a Chromium kiosk, and it publishes a clean

Claude Code keeps rereading repositories from scratch. I built an MCP layer that gives it architectural memory first.

I have been testing a problem that keeps showing up with coding agents: They can generate code well, but repository understanding is still expensive. Ask a codebase-level question and the agent often searches broadly, opens large files, and burns context reconstructing the same architectural map again. I built an open-source MCP server called Provenant to test a different approach. Instead of sending raw files first, Provenant builds a compact architectural memory layer for the repository: attributed wiki pages dependency context relevant file localization source citations confidence tracking asynchronous repair of weak pages On SWE-bench Verified: 500 real issues across 12 repositories C@10 file localization improved from 69.0% to 75.2% Flask retrieval context dropped from 69,044 tokens to 1,070 tokens 64.5× less context retrieved The goal is not to replace source code. The goal is to give the agent a map before asking it to walk through the entire city. Install: pip install provenant provenant init provenant serve GitHub: https://github.com/shreyash-sharma/provenant PyPI: https://pypi.org/project/provenant Whitepaper: https://www.shreyashsharma.com/writing/provenant I am looking for criticism from heavy Claude Code users. What repository-level questions still fail badly with your current setup? submitted by /u/lolfaquaad [link] [comments]

Since last week, Opus became lazy. I have never experience this before. Max thinking, Opus 4.7-4.8

First of all, I want to say that this post isn't about "Opus 4.8 was already nerfed!!!!". I want to share my frustration with the use cases that worked before. I don't think this breaks the rules about "complaining about bugs". I have been using Claude Code with Opus (max thinking) for months for a variety of tasks - work, writing/editing notes, Machine Learning competitions and usually was happy with the performance. But since the beginning of this week, or maybe since last week, I have experienced a lot of cases of Opus's laziness: I give it clear instructions on what to do, but the agent skips several of them. Today I got frustrated and asked it why it was happening and what I should change in my instructions/prompts. You can see the answer in the screenshot. I have no idea what the reason is for this regression (btw, I felt that Codex became more lazy this week too), but this really hurts. I wonder if other peopl submitted by /u/Artgor [link] [comments]

What I learned building a debugger for PyTorch training loops and how it changed how I think about failure diagnosis [D]

Hey r/ML, I spent the last few months building a tool that hooks into PyTorch training loops to automatically detect and localize failures (vanishing gradients, exploding gradients, data anomalies). Along the way, I learned some things about training failure diagnosis that might be useful even if you never use the tool. The key insight: most training failures are local, not global When your loss spikes or vanishes, the natural instinct is to look at the loss curve. But the loss is a global aggregate — it tells you something went wrong, but not where. In my testing across hundreds of synthetic failure scenarios, the actual root cause is almost always localized to a specific layer at a specific step: Vanishing gradients: the failure starts at the deepest layer with saturated activations, then propagates backward Exploding gradients: the failure starts at the layer with the highest gradient norm, then propagates forward Data anomalies: the failure starts at the input layer, then corrupts everything downstream The trick is to monitor per-layer gradient norms and detect transitions (healthy → vanishing), not absolute values. What actually matters in gradient monitoring Most people monitor: - Loss over time (too global) - Gradient histograms (too noisy, too much data) - Weight norms (slow to change, lagging indicator) What I found works best: - Gradient norm transitions: "Linear_3 went from healthy (0.12) to vanishing (0.00003) at step 47" - First occurrence tracking: which layer failed first (this is usually the root cause) - Activation regime shifts: when activations go from normal to saturated/dead This is basically what NeuralDBG does under the hood — I open-sourced it recently and it's on PyPI (pip install neuraldbg) if anyone wants to try it. The key design choice was to extract semantic events (transitions) rather than raw tensors — this makes the output small enough to reason about. Practical takeaway you can use today Even without any tool, you can add this to your training loop: ```python One-time gradient norm snapshot per layer if step % 10 == 0: for name, param in model.named_parameters(): if param.grad is not None: norm = param.grad.norm().item() if norm 1e3: print(f"WARNING: exploding gradient at {name} step {step} (norm={norm:.2e})") ``` This won't give you causal hypotheses, but it will catch 80% of training failures early. Questions for the community How do you currently debug training failures? Print statements? TensorBoard? Something custom? Have you found that failures are typically localized to specific layers, or more distributed? What's your "go-to" debugging workflow when loss goes to NaN? Curious to hear what works for people in practice. Links (for those interested): - GitHub: https://github.com/LambdaSection/NeuralDBG (MIT, open-source) - Quickstart: pip install neuraldbg submitted by /u/ProgrammerNo8287 [link] [comments]

pg-mnemosyne-mcp – Give your Cursor & Claude Code assistants persistent PostgreSQL memory and task tracking

Hi everyone! I was tired of my AI coding agents losing context across different chats or stepping on each other's toes when running multi-agent sessions. So I built **pg-mnemosyne-mcp**, a high-performance Model Context Protocol (MCP) server for PostgreSQL. It does three things really well: **Persistent Super Memory**: Let's your AI store key-value memories with tags directly in a local or cloud Postgres DB. **Dynamic Task checklists**: Prompts a specialized task board for AI tracking. **Agent Coordination Hub**: If you run multiple agents (e.g. Claude Desktop and Cursor), they register their active files and tasks in a shared database to prevent merge conflicts. Setup is a single command: `pg-mnemosyne init --dsn "..."` (it auto-configures Claude Desktop, Cursor, Roo Code, Windsurf, Claude Code, and more). It's fully open-source! If this sounds useful to your workflow, I'd love for you to try it out or drop a ⭐ to support the project! 👉 **GitHub**: https://github.com/Janadasroor/pg-mnemosyne-mcp 👉 **PyPI**: https://pypi.org/project/pg-mnemosyne-mcp/ submitted by /u/janadasroor [link] [comments]