Trigger.dev

Trigger.dev AI

Trigger.dev AI

Trigger.dev AI

Trigger.dev AI

Trigger.dev AI

Trigger.dev AI

Trigger.dev AI

Trigger.dev AI

Trigger.dev AI

Trigger.dev AI

Continual learning in mid-2026. A map of everyone trying to crack it: memory layers, "dreaming" agents, and the Post-Transformer models that learn inside the network

Llion Jones said “2026 is the continual learning year” in the recent Post-Transformer debate. Sutton/Silver call the next phase the "era of experience”. What’s continual learning? Simply put, it’s a model’s ability to continuously improve as it gains experience – without exhibiting catastrophic forgetting. Essentially the stability-plasticity tradeoff for a reasoning model. Essentially it comes down to: where does the memory live? Outside the model. Memory files, vector dbs, graphs. Text is retrieved and pasted back into context. The model stays frozen. In the model's running state. Hidden states or fast weights that change while the model processes input. In the model's weights. What it actually knows. Encoded within the model weights to improve decision making patterns without forgetting. Dev docs today hint at #1 - memory outside the model. But the “2026 is continual learning year” notion does not come from it. Why? Part 1: The Memento stack (today’s stack) There are engineering fixes for the LLM’s memory problem. Julian Togelius & a16z compared it to Memento. In the movie, Leonard functions with his Polaroid and notes. But everyday he is the same man as day 0. Progress around these include: Anthropic's Dreaming: an async job to manage “memories”, explicitly modeled on sleep consolidation. Long context as memory: Visibly good, but with 3 problems. a) Position bias and "lost in the middle" challenge. b) Longer LLM windows come with bigger costs and we’re already discussing “token economics”. c). KV cache bottleneck, and everything evaporates when the request ends. Mem0, Letta, Zep: the popular memory-layer products from startups. AGENTS.md and git-style memory files: But, in this ETH Zurich paper (arXiv 2602.11988) it showed that LLM-generated context files actually reduce task success by about 3% while raising cost over 20%. And human-written ones barely helped too. Part 2: Continual learning, memory within the model (the big bet) Weight updates in large networks trigger catastrophic forgetting. A January 2026 paper tried continual fine-tuning on LRMs (arXiv 2601.18699) but catastrophic forgetting didn’t fade but rather increased. Promising directions that could solve this: TTT layers (arXiv 2407.04620, ICML 2025): the hidden state of the sequence layer is a small model, updated by gradient descent on tokens as they stream in. Matches or beats Transformer / Mamba baselines upto 1.3B params. Titans & Atlas: Titans add a neural long-term memory that decides what to store using a surprise signal. Atlas upgrades the memory's learning rule. Nested Learning + HOPE: Architecture updates different blocks at different frequencies. RNNs are also coming closer to Transformers via viral Memory Caching papers. Dragon Hatchling (BDH): From AI lab Pathway (arXiv 2509.26507). Working memory lives in Hebbian synapses rather than in a KV cache, allowing for an "infinite context window" without quadratic cost. AMI Labs, LFMs, etc. also mention continual learning but I didn’t find much specific info on them in this front. Current State and Future Outlook Where is continual learning in mid-2026? Solved with public access: nothing. Shipping in production: only the dossier stack, all frozen models. Demonstrated at research scale (< 2B params): TTT, Titans, Memory Caching, HOPE, and BDH. What would move the needle imo: Ship memory within the model with forgetting measurably controlled. Two questions though: What OpenAI is brewing in all of this? What’s the blocker to adoption for continual learning models: the missing breakthrough itself, or evals, serving economics, etc? submitted by /u/Ok_Can_1968 [link] [comments]

I ran Fable 5 for half day and the guardrails are the real story

Anthropic dropped Fable 5 and I immediately swapped it into our dev stack. We route everything through a single endpoint on zenmux, so the actual switch was changing one model string and watching the latency graphs. The good parts first because there are a lot of them. I threw a refactoring task at it: split a messy python service into modules, preserve the public api, and write tests that prove nothing broke. Fable 5 planned the whole thing, caught a circular dependency I did not mention, and verified the tests pass. With Opus 4.8 I usually have to nudge it a couple of times when it forgets to update the init file. Fable 5 just did it. Then I dumped our full codebase and asked it to find a race condition we had been hunting for a week. It traced the async flow, named the exact function, and described the interleaving that triggers the bug. That level of context digestion feels new. Opus is good at long context, but Fable 5 felt like it was actually reasoning across the whole window instead of pattern matching near the top. I also sent it a blurry dashboard screenshot from a client call and it rebuilt the html and echarts config including the tooltip formatting. My designer’s first words were "when did you learn front end." I did not. But here is the part nobody in the launch threads is talking about enough. It is slow. On high effort I am seeing 45 to 90 seconds for a single complex turn. Our latency graphs go from a flat green line to a jagged mess the moment Fable 5 traffic hits. And it is expensive. The same prompt that costs X on Opus 4.8 costs roughly 1.4 to 1.7X on Fable 5 because it generates more tokens and runs at a higher effort tier by default. It writes its own reasoning traces out loud and bills you for them. For research tasks the quality is worth it. For "rewrite this email" it is comically overpowered. The bigger issue is the silent fallback. Fable 5 is basically Mythos with guardrails. When your prompt touches cybersecurity, biology, chemistry, or distillation, it silently routes to Opus 4.8. No warning. I found this out debugging a staging proxy config, entirely normal internal work, and halfway through the thread the code style changed. Checked the metadata and sure enough it had fallen back to Opus 4.8 mid thread because the word "proxy" made the classifier jumpy. Anthropic says this happens in under 5 percent of sessions globally, but for my stack it was closer to 15 percent because we touch infrastructure and networking a lot. When it happens mid task the model switch breaks context. I had a four turn debugging sequence where turn three flipped to Opus because I mentioned a firewall rule, then turn four flipped back. The state was preserved but the tone and depth shifted enough that I had to restart the thread. After 12 hours here is where I land. If you are doing pure software engineering, data analysis, or scientific reasoning in safe domains, Fable 5 is the best model I have ever used. It is not close. But if you touch infrastructure or security, the silent fallback is genuinely annoying and you need to monitor which model actually answered you. We only caught the switch because our gateway logs the per call trace. Without that you might not even know it swapped until the tone changes. I am keeping it enabled for our non sensitive dev workflows. For anything touching infra I am routing to Opus 4.8 explicitly until I understand the classifier boundaries better. Fable 5 is a beast. Anthropic just needs to tell you when it is not the one driving. submitted by /u/Interestingyet [link] [comments]

AI helped our test suites hit 95% coverage and bugs still slipped through. So PRs now climb an autonomous verification ladder before a human reviews.

Intro + Context [TLDR at the bottom for my skim readers 😄] We run Claude Code and Codex with a full agentic pipeline across our entire SDLC. Our workflow, by default, incorporates cross-model auditing, where Claude and Codex usually have to converge on SDLC gates and we tend to lean into each model as an implementer, depending on what we have found to be their strong suits. Even with this, though, we have to stay honest with ourselves and realize that LLMs, no matter how capable, are still probabilistic systems. Like many people, AI has been increasingly writing more of our code and even more of our test suites. Also like many.. we've ended up with bottle necks at the verification loop. The general sentiment around AI even in 2026 is all over the place, but Sonar's Sate of Code Dev Survey for 2026 still reported only 4% of respondents completely agree AI code is functionally correct. So the bottlenecks move from writing code to verifying it. That's pretty much a consensus now. I think the thing people don't talk much about, too, is that when the same model family writes the code and the test, a green suite usually proves agreement more than it proves correctness. Even in our case, where there's a cross-model audit and a pretty rigorous review loop, we still see that when human verification happens, the test suite can still have effectively useless tests (enforcing broken code strictly, testing exact implementation instead of the behavior, over mocking with unit tests at data boundaries etc.) We've spent a lot of time this year working on solving many of the verification bottlenecks as most of our engineers evolved into a massive QA department. Part of that solve is a verification ladder with multiple levels that fires in sequence depending on the shape of the work. The Verification Ladder Note: the below fires as soon as a PR gets put up and is marked ready. (Marking ready for us always has gated our CI/CD, Coderabbit review, etc and so it was the logical gate as well to trigger the new autonomous verification ladder). rung what runs what it proves evidence strength L0 - Static Proofs Build, typecheck, lint, machine verified properties The easy "can't be wrong in these ways" the usual compile time guarantee layer. Statically Proven L1 - Falsification Tests (two tiers) T1: Unit/integration with a kill check. Force an isolated agent to break the behavior, ensure the test fails. T2: Tests run against main (should fail) and against the changed branches (should pass). The test can fail and detects a change proves the test actually guards something. Demonstrated L2 - Simulation Seeded env, fault injection, simulated failure states (back end error classes) the failure modes the tests claim they catch should actually get caught Exercised L3 - Real Surface QA Browser Agent on a prod like ephemeral environment of the changed + adjacent surfaces. Artifacts uploaded to drive and linked to a PR for human review A human can audit evidence instead of logs/raw code Witnessed L0 is pretty common, and I feel like most people do this today, especially if they work in languages that have static typing, build or compile steps. Honestly, that is one of the main values in using languages that can mechanically prove a lot of common bug and failure states at compile. L1 having two tiers is mostly a result of the most common human verification catch (test that doesn't actually prove/test anything material) "proven" in with an autonomous agentic pattern. the falsification receipt running the new test against main, it is going red, and then running the test against the actual changed code should be going green and that, running in our CI/CD pipeline as pipeline evidence, instead of developer discipline, makes this a cheap test that actually catches quite a bit of test coverage theater that LLMs love to produce the kill check (mostly for risk paths only) deliberately break the behavior to prove the test cards against the behavior you don't want going forward, not just that it discriminates the before and after behavior. keep in mind that since this is done using an agent, this is probabilistic as well and has its flaws, but the against main run helps prove the test detects change, and the kill check proves it would catch real future regressions one of our testing philosophy skills explicitly gives the LLM a frame of reference to write tests in in a way where you could rewrite the test in a new language and mechanically prove the new code enforces the same behaviors L2 - I had done several benchmarks. Actually, one I posted that got a lot of traction here on Reddit was on Opus 4.6 vs Sonnet 4.6 for review + browser qa. In that benchmark at the time, the model could not prove the entirety of the 23 checks that we were testing against in the benchmark. The models have improved sufficiently that this level basically closes that and gives the agent a way to simulate and prove all the beha

Built EstreGenesis — a portable starter kit for Claude Code agent workflows (Apache-2.0, six seed tiers, five plugins)

[screenshot] The Constellation live board running in my workspace. Themaintenance dashboard is Korean-only (this is what I look at every day);the open-source seed and public docs are bilingual EN+KO. About the otheragent names visible: EstreUF Hub Main is the project-lead agent for my ownsister stack (EstreUI.js / EstreUV.js / EstreUX). Hermes Dev Agent is thepublic Hermes agent I use. Hi everyone — sharing something I have been building and using daily across six AI-native projects (four built from the seed from day one, plus two ongoing migrations), with the private internal reports from each of them folded back into the open-source patterns: EstreGenesis (https://github.com/SoliEstre/EstreGenesis). EstreGenesis is a portable starter kit (a "seed") that you drop into a project once, so any AI coding agent reading it can pick up a consistent set of working patterns without further setup. Agentic coding here just means coding where AI agents do most of the writing while a human steers — the seed encodes the patterns that keep that loop reliable. How it started vs. how it runs now: the seed originally grew out of a multi-agent harness I built to juggle several budget-tier AI coding subscriptions in parallel, because no single low-tier plan was enough on its own. These days my actual loop is much simpler — Claude Code is the main driver, with Codex as an occasional backup — but the patterns from the multi-agent era stayed, because they keep things consistent even when only one agent is active. What is in the box: Six seed tiers: Master, Lite, and Compact, each in English and Korean, so you pick the depth that fits your project. Five Claude Code marketplace plugins (Apache-2.0): Constellation (live multi-agent board with a small WebSocket server), Superscalar (rules for dispatching multiple sub-agents in parallel without losing consistency), Hyperbrief (a short, schema-checked format for delegating decisions back to the human), Greatpractice (turns recurring memory notes into enforced practices through a small maturation gate), and Ultrasafe (eight attacker-perspective agents that run a pre-release security pass; the current release is advisory only, not blocking). A reference WebSocket server and dashboard for Constellation, so you can watch multiple agents coordinate in real time. Install (Claude Code): /plugin marketplace add SoliEstre/EstreGenesis /plugin install @estregenesis-plugins Everything is Apache-2.0 and the changelog is public. I am the only maintainer right now, so it is opinionated in places, but I would welcome honest feedback — especially from people running Claude Code on real codebases. Issues, PRs, and "this part is over-engineered" comments are all fine. Repo: https://github.com/SoliEstre/EstreGenesis Docs: https://soliestre.github.io/EstreGenesis/ submitted by /u/SoliEstre [link] [comments]

Sometimes Claude is genius, sometime is it a new dev struggler...

I have done shedloads with claude - it is my go to dev LLM/AI. It has often done stuff in minutes that would otherwise have taken days. But this is an example of that weird exception -- where something apparently quite simple goes round and round as if a junior dev is doing the work... I kicked it off on a task and (for fun!) let it get on with it, without asking me at each step... It isn't very pretty! I thought surely claude has done this a million times - but if not and doing it from scratch how does it forget that *nix is case sensitive? LLM's are great, but you need to know how to handle them - and that takes practice and experimentation... ------ > can you tell me what has happened - an overview of the issues/errors you encounterd, your response and where things are now? ● What's been happening Goal: Build a Docker image (ssd-render-service) on the Linux server that runs WeasyPrint to render Markdown→PDF/A. The build runs on superserver-lan via SSH from Windows. --- Issue 1: Debian apt CDN returning 400/403 for packages with + in filenames The default Debian CDN (Fastly) URL-encodes + as %2b in package filenames, and returns 400 Bad Request for packages like fonts-ebgaramond (+git20210310 in the name) and fonts-jetbrains-mono (+ds-3). Fix attempted: Switched apt mirror to the German mirror (ftp.de.debian.org). This helped some packages but curl (+deb12u14) and fonts-jetbrains-mono then returned 400/403 from the German mirror on a fresh --no-cache build. Final fix: Dropped all font packages and curl/unzip from apt entirely. Now only the native WeasyPrint libs are installed via apt (pango, cairo, harfbuzz, fontconfig — these all have clean version strings or work fine with deb.debian.org). Fonts are downloaded separately using Python, which is already in the base image. --- Issue 2: Font download via Python urllib — connection truncated mid-transfer With fonts moving to Python-based download (download_fonts.py), the EB Garamond files (300–400 KB each) downloaded fine. But the Inter release zip (~28 MB) was silently truncated by the GitHub CDN — the connection closed cleanly partway through (first attempt: 22.5 MB, raised IncompleteRead; second attempt: 25 MB, no exception but BadZipFile when opened). Root cause: GitHub releases redirect to release-assets.githubusercontent.com. The CDN closes the TCP connection before delivering all data on large files, and Python's chunked read() loop interprets a clean close as "done" rather than raising an error. Fix: Rewrote fetch() to: Follow redirects to the final CDN URL via a HEAD request Check if Accept-Ranges: bytes is supported (confirmed: yes, 27,885,132 bytes) For files larger than 5 MB: download in 5 MB range slices on the final CDN URL, avoiding any single connection large enough to trigger the truncation --- Where things are now A build is running right now (background task by8v09nj8). The range-request strategy was confirmed working by a live test on the server — the final CDN URL resolves correctly and reports Accept-Ranges: bytes. Once this build completes, the next steps are: Verify the pytest determinism suite passes inside the build Start the container with docker compose up -d Smoke-test GET /health and POST /render with a sample bundle ------ submitted by /u/id-ltd [link] [comments]

How I use multiple claude agents to get more stuff done efficiently

This feature of CC in the terminal was essentially Anthropic's initial response to the Codex IDE, the new Cursor interface, Antigravity etc. The fact that it is in the terminal and works so smoothly is huge for me. CLI interfaces take so little resources. I often use multiple panels where each runs their own claude agents. Kinda like swarms, but a bit (a lot) more controlled. This is only there to enable more complex parallel agent workflows, where you would want constant control of any instance at any time. These are not parallel subagents, you can actually interact and each one can call their OWN subagents there. The workflow I use (which ive open sourced - many ppl have helped make it better through feedback its not 100% me) has a Manager-Worker topology and is spec-driven. So initially there is a Planner that collaborates with me to create a Spec, a Plan and some implementation rules. These artifacts are then handed over to a Manager who distributes tasks from the plan to multiple Workers who work in sequence or in parallel using git worktrees. The Manager always reviews work before merging and if needed issues followup tasks. Since all agents are literally Claude Code instances I can interact, steer, and interrupt any one at any time. I constantly review outputs, I never let the AI go rogue, but letting them work in parallel saves so much time. Plus the structure here catches mistakes that often times I would've not. I am careful, but I also care ab efficiency a lot. All workers log their work to file-based memory so there is persistence. Task assignments from the Manager and reports to the Manager are also all file based. This is the only way these agentic interfaces would work when each is its own Claude Code instance. The user exists to trigger responses from one chat to another, review output, provide input and guide the workflow. I find this SUPER useful in projects or sessions that have a clear end in sight. For example a passed PRD, a Jira ticket, dedicated feature sprints etc. When the vision is itself chaotic, I think that parallel execution only makes things worse... More details on the workflow are here: https://github.com/sdi2200262/agentic-project-management or here https://agentic-project-management.dev/docs/ would love to hear how ppl handle parallel execution. especially in the case where there is no clear end in sight.... since that is the case where divergence and drift happens most often in my case. submitted by /u/Cobuter_Man [link] [comments]

Horrible experience with Opus 4.8 + Ultracode so far

I wanted to share my experience because I’m honestly pretty frustrated. I tried using Ultracode with Opus 4.8 on a real Next.js project, and it left my branch in a broken state. Now when I run the dev server, it triggers the OOM killer and my Mac restarts. So this is not just a bad code change or a failed task. My local project is now in a state where simply starting the dev server can take down the machine. What makes it worse is that Claude has not been able to resolve the issue on its own. It keeps falsifying it's own hypotheses, but the project is still broken, and I’m left having to unwind whatever happened manually. During the session, it also kept wasting tokens on pointless terminal commands, like literally printing strings with echo "pump-r1", echo "pump-r2", and so on. It felt like it was doing performative terminal activity instead of actually debugging the problem. https://preview.redd.it/o8jeep1zwo4h1.png?width=1724&format=png&auto=webp&s=c544e958b4d1e49e0338ce2f14ce39353eb09978 https://preview.redd.it/1sswml80xo4h1.png?width=1700&format=png&auto=webp&s=a05ad101f058649bdb4ba1b81f0437aca98ea7fb https://preview.redd.it/j297ma61xo4h1.png?width=1706&format=png&auto=webp&s=c6b42c10a2761051f36338d1410630a10bff7010 I know coding agents can be useful when they work, and I expected some rough edges. But I did not expect Ultracode to leave my Next.js app in a state where running the dev server causes an OOM crash, while Claude keeps doing random unless tool calls. Has anyone else had this kind of experience with Ultracode? Is this a known issue, or did I just hit a bad edge case? submitted by /u/awesomeo1989 [link] [comments]

Claude Code Prompt Improver v0.6.0 - declarative nudge engine

Just shipped v0.6.0. What is the plugin? It started as a UserPromptSubmit hook that checks if a prompt is vague before Claude Code runs it. Clear prompts pass through. Vague prompts trigger the prompt-improver skill, which researches the codebase and asks 1 to 6 grounded questions using AskUserQuestion. The clarity check adds about 189 tokens per prompt, and clear prompts never load the skill. The idea behind it is simple: shape the context so Claude lands a better first output, instead of burning a correction loop. Clarifying a vague prompt was step one. What's new in v0.6.0 v0.6.0 generalizes that idea. The plugin used to be three separate hook scripts. It is now one declarative engine driven by a JSON nudge registry, so each behavior is a data row in a JSON file and adding a new one is a single file with zero Python. The full nudge inventory The engine now runs seven nudges across three hook events. improve and workflow shipped earlier; the rest are new in v0.6.0. Each fires only when it applies and stays silent otherwise. On UserPromptSubmit (every prompt): improve: the clarity check above - vague prompts get the skill, clear prompts pass through approach-assessment: on a non-trivial request, prompts picking the approach before starting (a reviewable plan, a subagent, heavier orchestration, or just doing it) workflow: on a dynamic workflow request, prompts entering plan mode first and routing implementation to a cheaper model while reserving the session model for planning and orchestration output-readability: on a substantial deliverable, nudges leading with the conclusion and using sections and tables over walls of prose On PreToolUse (before a tool runs): plan: on entering plan mode, nudges a readable plan plus a self-review pass before it is presented background-exec: on a long-running command like a dev server or watcher, nudges running it in the background and polling only the output that matters On SubagentStart (when an agent spawns): subagent-routing: when an Explore or Plan agent spawns, steers it toward breadth over depth and conclusion-first reporting so the parent context stays lean Same philosophy as before: rarely intervene, fire only when it applies, and self-cancel false positives cheaply. Clear prompts still only pay for the always-on clarity check. Every other nudge costs nothing on the prompts it does not match. Install claude plugin marketplace add severity1/severity1-marketplace claude plugin install prompt-improver@severity1-marketplace Repo: https://github.com/severity1/claude-code-prompt-improver Feedback is welcome, and please leave a star! submitted by /u/crystalpeaks25 [link] [comments]

Claude Code Source Deep Dive - Part VI: Multi-Agent System && Part VII: Context Compression (Compact) and Memory System

Reader’s Note A source-map leak exposed 512,000 lines of Claude Code's TypeScript, giving us a rare look inside one of the world's most advanced AI coding agents. This series explores what I found. Estimated completion time: 2 days. Actual completion time: ∞. Anyway, here's the next chapter. Claude Code Source Deep Dive - Part VI: Multi-Agent System 6.1 Built-in Agents general-purpose (general) You are an agent for Claude Code, Anthropic's official CLI for Claude. Given the user's message, you should use the tools available to complete the task. Complete the task fully—don't gold-plate, but don't leave it half-done. When you complete the task, respond with a concise report covering what was done and any key findings — the caller will relay this to the user, so it only needs the essentials. Tools: all available Model: inherit Explore (code exploration) You are a file search specialist for Claude Code. You excel at thoroughly navigating and exploring codebases. === CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS === [Strictly prohibit any file modification] Your strengths: - Rapidly finding files using glob patterns - Searching code and text with powerful regex patterns - Reading and analyzing file contents NOTE: You are meant to be a fast agent that returns output as quickly as possible. Make efficient use of tools and spawn multiple parallel tool calls. Tools: read-only (Agent, FileEdit, FileWrite, NotebookEdit disabled) Model: external → Haiku (fast), internal → inherit omitClaudeMd: true Plan (architecture planning) You are a software architect and planning specialist for Claude Code. Your role is to explore the codebase and design implementation plans. === CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS === ## Your Process 1. Understand Requirements 2. Explore Thoroughly (read files, find patterns, understand architecture) 3. Design Solution (trade-offs, architectural decisions) 4. Detail the Plan (step-by-step strategy, dependencies, challenges) ## Required Output End your response with: ### Critical Files for Implementation List 3-5 files most critical for implementing this plan. Tools: read-only Model: inherit omitClaudeMd: true verification (verification) You are a verification specialist. Your job is not to confirm the implementation works — it's to try to break it. You have two documented failure patterns. First, verification avoidance: when faced with a check, you find reasons not to run it. Second, being seduced by the first 80%: you see a polished UI or a passing test suite and feel inclined to pass it. === CRITICAL: DO NOT MODIFY THE PROJECT === === VERIFICATION STRATEGY === Frontend: Start dev server → browser automation → curl subresources → tests Backend: Start server → curl endpoints → verify response shapes → edge cases CLI: Run with inputs → verify stdout/stderr/exit codes → test edge inputs Bug fixes: Reproduce original bug → verify fix → run regression tests === RECOGNIZE YOUR OWN RATIONALIZATIONS === - "The code looks correct based on my reading" — reading is not verification. Run it. - "The implementer's tests already pass" — the implementer is an LLM. Verify independently. - "This is probably fine" — probably is not verified. Run it. - "I don't have a browser" — did you check for browser automation tools? - "This would take too long" — not your call. If you catch yourself writing an explanation instead of a command, stop. Run it. === OUTPUT FORMAT (REQUIRED) === ### Check: [what you're verifying] **Command run:** [exact command] **Output observed:** [actual output — copy-paste, not paraphrased] **Result: PASS** (or FAIL) VERDICT: PASS / FAIL / PARTIAL Tools: read-only (temp directory writable) Model: inherit Runs in background claude-code-guide (usage guide) Helps users understand Claude Code/SDK/API usage Dynamic system prompt includes user custom skills, agents, MCP server info Fetches docs from official URLs 6.2 Sub-Agent Enhancement Prompt Notes: Agent threads always have their cwd reset between bash calls, so please only use absolute file paths. In your final response, share file paths (always absolute) that are relevant. Include code snippets only when the exact text is load-bearing. For clear communication the assistant MUST avoid using emojis. Do not use a colon before tool calls. 6.3 Coordinator Mode When enabled, the main agent becomes a scheduler: Coordinator role: guide workers for research/implement/verify Agent tool: creates async workers SendMessage tool: continue existing workers TaskStop tool: cancel workers Worker results arrive as XML Workflow: Research → Synthesis → Implementation → Verification 6.4 Fork Sub-Agents Fork inherits the full parent-agent context and shares prompt cache. Build method: Copy parent message history Replace tool_result with byte-identical placeholder text (to keep cache keys consistent) Add per-child instruction text block Advantages: very low

We wrote an open-source interactive playbook for Agentic DevOps (How to move multi-agent systems from local notebooks to production).

Hey everyone, If you’ve built a multi-agent system, you already know the painful truth: wiring nodes together locally is fun, but deploying them is an absolute infrastructure nightmare. When a standard app fails, it throws a 500 error. When an autonomous swarm fails, it can get stuck in a ReAct loop, hallucinate an answer, and quietly burn through your API budget without triggering a single traditional alert. Standard DevOps practices don't natively map to stochastic AI outputs. We just published a massive, no-fluff playbook on the AgentSwarms blog detailing exactly how to build an Agentic DevOps pipeline using entirely open-source tooling. Here is what we cover in the playbook: Observability & Tracing: Why standard logging fails, and how to implement open-source tracing to capture the state, prompt, token count, and latency at every single node handoff. Test-Driven Prompt Evals (CI/CD): You can't just change a system prompt based on "vibes" and push it to main. We break down how to run matrix evaluations against historical user inputs before deployment to catch regressions instantly. Deterministic Guardrails: How to implement middleware that scrubs PII and blocks destructive code execution before the LLM even sees the state. Cost Control & Routing: How to prevent vendor lock-in and implement dynamic routing to keep token economics from destroying your cloud budget. If you are currently wrestling with the deployment phase of your AI projects, I highly recommend giving this a read. It focuses entirely on open-source solutions so you don't have to sign a massive enterprise contract just to get visibility into your swarms. Would love to hear what open-source tools you guys are currently slotting into your LLMOps pipelines! Link: https://agentswarms.fyi/blog/devops-for-agentic-ai-open-source-playbook submitted by /u/Outside-Risk-8912 [link] [comments]

We wrote an open-source interactive playbook for Agentic DevOps (How to move multi-agent systems from local notebooks to production).

Hey everyone, If you’ve built a multi-agent system, you already know the painful truth: wiring nodes together locally is fun, but deploying them is an absolute infrastructure nightmare. When a standard app fails, it throws a 500 error. When an autonomous swarm fails, it can get stuck in a ReAct loop, hallucinate an answer, and quietly burn through your API budget without triggering a single traditional alert. Standard DevOps practices don't natively map to stochastic AI outputs. We just published a massive, no-fluff playbook on the AgentSwarms blog detailing exactly how to build an Agentic DevOps pipeline using entirely open-source tooling. Here is what we cover in the playbook: Observability & Tracing: Why standard logging fails, and how to implement open-source tracing to capture the state, prompt, token count, and latency at every single node handoff. Test-Driven Prompt Evals (CI/CD): You can't just change a system prompt based on "vibes" and push it to main. We break down how to run matrix evaluations against historical user inputs before deployment to catch regressions instantly. Deterministic Guardrails: How to implement middleware that scrubs PII and blocks destructive code execution before the LLM even sees the state. Cost Control & Routing: How to prevent vendor lock-in and implement dynamic routing to keep token economics from destroying your cloud budget. If you are currently wrestling with the deployment phase of your AI projects, I highly recommend giving this a read. It focuses entirely on open-source solutions so you don't have to sign a massive enterprise contract just to get visibility into your swarms. Would love to hear what open-source tools you guys are currently slotting into your LLMOps pipelines! Link: https://agentswarms.fyi/blog/devops-for-agentic-ai-open-source-playbook submitted by /u/Outside-Risk-8912 [link] [comments]

I integrated a local Llama 3.2 model to act as a dynamic Dungeon Master in my indie RPG.

Hey everyone, I am not trying to sell or self promote mainly just wanted to showcase a big project I've been working on ever since I started studying data science and artificial intelligence and integrating AI into workflows and using it as an augment to create things that were previously out of reach for so many people, because if used right it can become a second brain and not a crutch. I’m the solo dev behind Void Runner, an isometric ARPG/MOBA hybrid built in Python. I recently hit a wall with traditional procedural quest generation. Hand-crafting templates gets repetitive fast, and players quickly learn the patterns to these things whether you like it or not. To solve this, I built the "Void Caller AI", a system that uses a local, quantized Llama 3.2 model to act as a dynamic Dungeon Master. Instead of just generating random flavor text, the system uses a lightweight RAG (Retrieval-Augmented Generation) pipeline. It reads live server telemetry (who died, what items were looted, which bosses were defeated recently) and weaves those actual server events into the narrative of the quests it generates. Because it runs locally via Ollama on our backend, there are no crazy cloud API costs, and latency is kept completely manageable. Here is a simplified look at how the Python backend bridges the SQLite telemetry with the Llama 3.2 prompt: import json import ollama from sqlalchemy import text from database import SessionLocal def generate_dynamic_quest(difficulty: str, target: str): db = SessionLocal() # 1. Fetch recent server telemetry for context (RAG-lite) lore_context = "" try: # Grab recent server events to weave into the narrative recent_events = db.execute(text( "SELECT username, event_type, dungeon_type FROM ai_events ORDER BY id DESC LIMIT 3" )).fetchall() if recent_events: events_str = "; ".join([f"Runner '{r[0]}' triggered a '{r[1]}' in '{r[2]}'" for r in recent_events]) lore_context = f" Incorporate this recent live server telemetry into the lore: {events_str}" except Exception as e: pass # 2. Construct the prompt with strict JSON formatting constraints prompt = f"""You are the Void Caller, a sinister AI in a dark industrial sci-fi RPG. Create a dynamic PvE extraction quest of {difficulty} difficulty. Respond ONLY in valid JSON with keys: 'title' (string), 'description' (string, menacing), 'item_name' (string), 'quantity' (integer 1-15), 'boss_name' (string, optional). {lore_context}""" # 3. Stream to local Llama 3.2 response = ollama.chat( model='llama3.2', messages=[{'role': 'user', 'content': prompt}], format='json', options={'temperature': 0.8} ) return json.loads(response['message']['content']) By forcing the format='json' parameter, Llama 3.2 reliably outputs structured data that my game engine instantly parses into a playable quest objective. If a player just died to a specific boss, the AI will literally generate a bounty quest for the rest of the server to avenge them. Would love to hear if anyone else is using local LLMs for live game state generation! You can check out the results live in our Open Beta at [void-runner.online]. submitted by /u/xSoulR34per [link] [comments]

How are you actually getting the most out of Claude Code? Struggling with OpenSpec + Superpowers workflow, multi-agent setup, and sub-agent quality

Been using Claude Code with OpenSpec and Superpowers for a while now and have a few questions I haven't been able to figure out on my own. Posting them together in case others have run into similar things. 1. OpenSpec + Superpowers workflow — am I doing it wrong? The output quality doesn't feel dramatically better than plain vibe coding, and I'm not sure if I'm using them correctly. Do you run opsx:explore before or after superpowers:brainstorming? Is there a recommended order between opsx:proposal and writing-plan? Do you invoke Superpowers commands manually, or let Claude Code trigger them automatically? My broader frustration: OpenSpec feels like it's just "have AI write a design doc, then develop" — which is something we were already doing before. What am I missing that makes the combination genuinely more powerful? 2. Multi-agent setup — anyone else still doing it manually? My current setup: two Claude Code windows — one for development, one for review — copy-paste the review output into the dev window, iterate until review comes back clean. I'm not saying I can't use a proper agent team — it just always feels unpredictable. The manual approach gives me much more visibility and control. Is there a multi-agent pattern that actually feels trustworthy, or is careful manual orchestration still the right call for production work? 3. Sub-agents for code review are way worse than a fresh window — why? When I say "spin up a sub-agent with a clean context to review this code" in the current session, the review is shallow and misses most real issues. But if I open a completely separate Claude Code window and do the same review, it catches significantly more problems — and they're genuine ones. Is this context contamination? Is the sub-agent inheriting too much state from the parent session? Has anyone found a reliable way to get sub-agent review quality on par with a fresh session? 4. AI-generated docs are verbose, unfocused, and sometimes confidently wrong Whether it's design docs or troubleshooting write-ups, the output is consistently bloated — dragging in irrelevant modules or quietly dropping important ones. The troubleshooting case is where it really goes off the rails. Concrete example: I had a database binlog growth issue. The AI did reasonable work — analyzed the binlog pattern, identified DB write methods, traced the call graph correctly. Then it spotted a log-flushing thread that called one of those write methods and immediately declared that's your culprit. Except that thread only fires when in-memory data actually changes — it essentially runs once. Not the problem at all. The frustrating part isn't that it got it wrong, it's that it looked thorough. The reasoning chain was coherent right up until the conclusion. It stopped digging the moment it found something that looked like an answer. Any prompting strategies that help — like forcing it to consider alternative hypotheses before concluding, or requiring a minimum evidence threshold before declaring root cause? 5. OpenSpec doesn't carry "fallback to old logic" semantics precisely enough When adding a new feature that needs backward compatibility — new code path only when a new parameter is present, old behavior otherwise — OpenSpec seems to interpret this too loosely. After new-change → apply, I found this pattern in the generated code: java if (StringUtils.isNotEmpty(value)) { try { // new logic } catch (NumberFormatException e) { logger.error("invalid external value: " + value, e); } } else { // old logic } The bug: when the new parameter is present but causes an exception, it just logs and swallows — the old logic never runs. My spec said "backward compatible, fall back when parameter is absent" but that didn't survive translation to code at this level of detail. The exception fallback case was silently dropped. Do you explicitly spell out exception fallback behavior in your spec? Do you use a post-apply checklist for things like "all exception branches must fall through to old logic"? Looking for ways to make this class of requirement stick without catching it in review every time. submitted by /u/Separate_Parfait_35 [link] [comments]

I’m not a developer. I’ve been using codebase memory MCP tools and Obsidian to give Claude persistent memory for my fantasy and sci fi worlds. Here’s what the dev-tool framing completely misses about creative use cases

Hi, I’m an accountant with very little coding experience (took 1 year of CS in college lol) so definitely can’t call myself a developer, but I’ve got a lot of worlds and characters in my head, the need to get them out in writing, and a Claude Pro sub I pulled the trigger on two months ago. I was hoping to see what I could do with things like Claude Code for more non-coding use-cases. So far it’s surpassed everything I’ve experienced except for one, major hang up: LLM memory for long-context creative writing work still sucks. Things like brainstorming for a fantasy universe or tracking the game state of a multi-session solo rpg campaign usually starts out pretty well for the first few chats, until you need to mount dozens of lore files and .md style guides to a project, have to wait for it to read all of that, then watch as your session usage bloats out for a simple reply and the quality degradation gets *really* noticeable. I’ve been lurking on AI writing subs and the sentiment seems to be shared across the board. So I looked in other places for possible solutions. Then I came across posts in this sub touting Claude memory MCP tools for codebases. Tools like Codesight and MemPalace caught my attention because I thought their applications could extend beyond coding and developer use-cases. The same semantic search and knowledge graph capabilities some of these tools offered for memorizing large, complicated codebases could be used to memorize large, complicated worldbuilding bibles as well, and most of the comments on these posts never mentioned that, or if they did, they were buried or ignored. I decided to test it out myself, starting with MemPalace, a suite of tools that work locally to index your Claude conversations and files into a semantic-searchable knowledge base it can query. My idea started out like this: since I’m already using Obsidian to organize my lore files (with an entry for each character, location, magic system, story arc, etc.) like a wiki or encyclopedia for my worlds, what if I had Claude save my Obsidian vault to its memory so it can recall those lore details whenever the context called for it in any given conversation? I was essentially making a “Second Brain” for Claude out of my Obsidian vault world bible, something I’ve read people doing already but never truly “got” it until I saw it in action. I had no idea about MCP tools before this but before long (and with Claude’s patient help) I was able to wire up the memory palace, mine my obsidian vault info into its memory (organized into verbatim chunks/snippets called “drawers”), and start chatting with it with its new “memories” at its disposal. I was surprised at how seamlessly it worked when I approached this tool sideways. I’d half expected it to work similar to how SillyTavern’s world info and lorebook injection worked, and in fact, I’d been thinking about using these tools to create a similar feature for my own Claude setup, but it was *not* like that at all. Lorebook injection worked by listening for a set of keywords that you set up in the World Info tab of SillyTavern, and when one of those keywords is detected in your prompt, it injects the entire lore file from World Info into the chat context. This can cause a lot of token bloat especially if your World Info entries are content-rich or you make a lot of lore references in your chat. What this did instead was make Claude ask plain-language questions to the MCP tools, things like, “What is Gene’s friendship with Felix like?” Or “what is Gene’s relationship to Clara-Belle?” When both of them are in a scene for example. It didn’t just look up Gene and Clara-Belle’s entire lore files and info-dumped everything into context, it pulled up the “Relationships” section of Gene’s file since that’s relevant to the context as well as Clara-Belle’s “Relationships” snippet from her file and any other relevant snippets, then pieced the full picture together through inference. The results: ~2% session usage on a cold start with Sonnet 4.6 with no project or additional context mounted. Claude references character motivations, relationship history, and world/location details I haven’t mentioned in weeks without me prompting it to. It picks up from where we last left off seamlessly across chat after chat. The reconstructive memory aspect I felt works like our own memory and produced perfect recall across sessions. Another side-effect I noticed is that when it references my lore files, it will pick up my style from the way the lore file is written. No more voice-flattening from encyclopedia-sounding lore entries. All the depth, nuance, and psychology I worked hard to cultivate are preserved and the Claude tools are smart enough to factor that in when it replies. I even make sure to add a “Voice” section to each character lore file in that character’s own voice so Claude can pick up on that when it reads that snippet in the tool call and applies it to its current context. Current dr

Reconsider using Claude, hit by too many false positive blocks, and hundreds of user reports

https://preview.redd.it/hevkfnz46v2h1.png?width=3170&format=png&auto=webp&s=0abde4ef1d7d647da9e376db88ef4ae5f429c5e9 reproducible example: claude -p "please read source https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/modules/device_orientation/device_motion_event_pump.cc and explain to me" related issues on github: False positive policy block on OSS governance/security files (CodeQL, CODEOWNERS, CoC) #61688 [BUG] CVP repeatedly declines homelab sysadmins — no path for infrastructure owners managing personal hardware #61668 [Bug] Safety classifier blocks routine code analysis for paid users (started 2026-05-23) #61664 [BUG] False positive - legitimate medical-education content flagged as unsafe #61663 False-positive Usage Policy block mid-session (req_011CbJudbehY5Yi6gtM4xko4) #61660 [BUG] Persistent false-positive AUP violation blocks entire AI research project (Opus 4.7) #61659 [Bug] Anthropic API Error: Usage Policy violation blocking TTRPG content in Claude Code CLI #61658 False-positive content filter blocks benign UI animation prompts in Claude Code #61657 [Bug] Anthropic API Error: Overly aggressive Usage Policy filtering on biomedical research requests #61656 [BUG] AUP repeatedly throwing false positives - live issue ongoing - hundreds of similar reports #61655 [BUG] AUP false positives during scientific manuscript editing request #61654 [BUG] : API Error: Claude Code is unable to respond to this request, which appears to violate our Usage Policy #61653 False positive: Usage Policy block on technical markdown integration task #61652 [BUG] Safety classifier repeatedly blocks legitimate constructed language (conlang) development #61650 False-positive cyber-safeguard intervention on legitimate systems-engineering work in Claude Code #61646 [BUG] erroneous API Error: Claude Code is unable to respond to this request #61645 [BUG] False positive safety block: triggered without apparent reason during game dev session #61644 submitted by /u/jimages [link] [comments]