PathAI

PathAI AI

PathAI AI

PathAI AI

PathAI AI

PathAI AI

PathAI AI

PathAI AI

PathAI AI

PathAI AI

PathAI AI

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

New AI model finds a cheaper path to healthier eating

Breakfast cereal bowls, deli sandwiches, pizza dinners, soups, yogurt plates. Most people do not eat from a blank slate, they eat from habit. That is part of what makes nutrition advice so hard to follow. It is also part of what a new artificial intelligence system tried to solve. submitted by /u/Brighter-Side-News [link] [comments]

AI for Apparel Manufacturing?

Hey everyone, hope you’re having a good weekend. I run an apparel manufacturing company, and we ship around 300k to 400k T-shirts every month. Over the last couple of years one of our biggest headaches has been finding enough labor and dealing with their unreasonably high demand in wages due to shortage of workers, on top of all the usual supply chain and geopolitical issues. I’ve been wondering whether sewing operations could realistically be automated with today’s AI and robotics. It seems like fabric handling is the biggest challenge. Unlike rigid materials, fabric is flexible, stretches, wrinkles, and can be different from one piece to the other. Do you think AI vision systems and machine learning could be trained to handle fabric the way experienced sewing operators do in real time? And most importantly, is there a realistic path to making something like this cost effective at scale for apparel manufacturing, as existing semi automatic machines are extremely expensive. I’d love to hear from anyone working in robotics, industrial automation, AI, or garment manufacturing. submitted by /u/Peacekeepermonkey [link] [comments]

Claude Code Source Deep Dive (Part 5) — Literal Translation & Tool-Call Loop Self-Repair Core Mechanism

Reader’s Note On March 31, 2026, the Claude Code package Anthropic published to npm accidentally included .map files that can be reverse-engineered to recover source code. Because the source maps pointed to the original TypeScript sources, these 512,000 lines of TypeScript finally put everything on the table: how a top-tier AI coding agent organizes context, calls tools, manages multiple agents, and even hides easter eggs. I read the source from the entrypoint all the way through prompts, the task system, the tool layer, and hidden features. I will continue to deconstruct the codebase and provide in-depth analysis of the engineering architecture behind Claude Code. 3.14 EnterWorktree Tool (Enter Worktree) Create isolated git worktree and switch current session into it. When to Use: - User explicitly says "worktree" When NOT to Use: - User asks to create/switch branches - User asks to fix bug or work on feature without mentioning worktrees - NEVER use unless user explicitly mentions "worktree" Behavior: - Creates new git worktree inside `.claude/worktrees/` with new branch - Switches session's working directory to new worktree 3.15 AskUserQuestion Tool (Ask User Question) Ask user multiple choice questions to gather info, clarify ambiguity, understand preferences, make decisions, offer choices. Usage Notes: - Users always able to select "Other" for custom text input - Use multiSelect: true to allow multiple answers - If recommend specific option, make first option with "(Recommended)" at end Preview Feature: - Use optional `preview` field on options when presenting concrete artifacts needing visual comparison (ASCII/HTML mockups, code snippets, diagrams) - Preview content rendered as monospace markdown - When any option has preview, UI switches to side-by-side layout 3.16 LSP Tool (Language Server) Interact with Language Server Protocol servers for code intelligence. Supported Operations: - goToDefinition, findReferences, hover, documentSymbol, workspaceSymbol, goToImplementation, prepareCallHierarchy, incomingCalls, outgoingCalls All Operations Require: - filePath, line (1-based), character (1-based) 3.17 Sleep Tool (Wait) Wait for specified duration. Usage: - When user tells to sleep/rest - When nothing to do / waiting for something - May receive periodic check-ins (tick tags) - Can call concurrently with other tools - Prefer over `Bash(sleep ...)` — doesn't hold shell process - Each wake-up costs API call - Prompt cache expires after 5 min inactivity 3.18 CronCreate Tool (Scheduled Task) Schedule prompts to run at future times. Uses standard 5-field cron in user's local timezone. One-Shot Tasks (recurring: false): - "remind me at X" → pin minute/hour/day to specific values Recurring Jobs (recurring: true, default): - "every 5 min" → "*/5 * * * *" - "hourly" → "0 * * * *" CRITICAL: Avoid :00 and :30 Minute Marks (when task allows) - Every user asking "9am" gets 0 9, causing thundering herd - When approximate: pick minute NOT 0 or 30 - "every morning around 9" → "57 8 * * *" (not "0 9 * * *") Durability: - Default (durable: false): lives only in Claude session - durable: true: writes to .claude/scheduled_tasks.json Recurring tasks auto-expire after 7 days. 3.19 TeamCreate Tool (Create Team) Create team to coordinate multiple agents working on project. When to Use (Proactively): - User explicitly asks to use team, swarm, or group agents - Task complex enough for parallel work Team Workflow: 1. Create team with TeamCreate 2. Create tasks using Task tools 3. Spawn teammates using Agent tool with team_name + name params 4. Assign tasks using TaskUpdate with owner 5. Teammates work on assigned tasks 6. Shutdown gracefully via SendMessage with shutdown_request IMPORTANT: Always refer to teammates by NAME. Plain text output NOT visible to other agents — MUST call SendMessage tool to communicate. 3.20 ToolSearch Tool (Deferred Tool Search) Fetch full schema definitions for deferred tools so they can be called. Query Forms: - "select:Read,Edit,Grep" — fetch exact tools by name - "notebook jupyter" — keyword search, up to max_results best matches - "+slack send" — require "slack" in name, rank by remaining terms submitted by /u/Ill-Leopard-6559 [link] [comments]

AI, Science & Economy: Systems Map

AI systems, particularly large language models, are often viewed as a direct path toward autonomous scientific discovery and rapid economic transformation. While their capabilities in pattern recognition, cross domain synthesis, and hypothesis generation are already exceptional, this view misses a critical reality: intelligence alone is not sufficient for progress. Scientific and economic breakthroughs depend on grounded interaction with reality, causal validation, and institutional execution. The following framework maps where AI creates value, where it is constrained, and why human–AI collaboration remains the dominant structure for meaningful real world impact. submitted by /u/vagobond45 [link] [comments]

AI Science & Economy: Systems Map

AI systems, particularly large language models, are often viewed as a direct path toward autonomous scientific discovery and rapid economic transformation. While their capabilities in pattern recognition, cross domain synthesis, and hypothesis generation are already exceptional, this view misses a critical reality: intelligence alone is not sufficient for progress. Scientific and economic breakthroughs depend on grounded interaction with reality, causal validation, and institutional execution. The following framework maps where AI creates value, where it is constrained, and why human–AI collaboration remains the dominant structure for meaningful real world impact. submitted by /u/vagobond45 [link] [comments]

Client Onboarding Solutions

I'm an AI automation consultant working with a fractional CRO company called Mo Commas. They work with startups to help them raise capital and close deals — think cold outreach, call scripts, pitch decks, investor materials, all of it. They're the sales arm for founders who don't have one. Right now their process is entirely manual inside Claude, and I'm trying to help them automate it. Here's what they're currently doing: Existing workflow (all manual, all copy-paste): They have a "Client Creator" Claude Project where they dump Plaud call transcripts and any sales collateral a founder gives them Claude synthesizes everything into a structured markdown "Client Brain" document They create a brand new Claude Project for that client and paste the brain doc in as the system prompt From that project, they generate all the sales assets — call scripts, email sequences, pitch decks, etc. Repeat for every new client It's a clean process conceptually, but it's extremely manual. Two founders are doing all of this by hand. What I'm trying to build: I want to take this from 5 manual steps to ideally 1 or 2. The input is a Plaud transcript + any sales collateral. The output is a full suite of sales assets ready to hand to the client. Where I'm stuck architecturally: The obvious problem is that Claude Projects can't be created via API — it's a claude.ai UI feature only. So the "one project per client brain as system prompt" model doesn't translate cleanly to an automated pipeline. The three paths I'm weighing: Path A: Keep them in claude.ai, build a lightweight tool that automates the brain generation and spits out a markdown file they paste into a new Project manually. Reduces steps but doesn't fully automate. Path B: Abandon claude.ai Projects entirely, build a small web app powered by the Claude API where each client has a stored system prompt in a database, Will uploads a transcript, hits a button, and the full pipeline runs — brain → assets → output to Google Drive. Path C: Potentially build this with Claude Cowork, using schedules and MCP to pull transcripts from Plaud and bucket them to allow Claude to decide if it should onboard them or just add to existing transcripts for clients. My constraints: The founders are 5/10 technical. Will leans in, Chris doesn't. Whatever I build needs to feel simple on their end. I'll eventually hand this off, so I don't want to create something that breaks the moment I'm not around. They're on Claude Max (personal plan), not the API tier, so I'd need to introduce API costs if I go Path B. My questions for the community: How would you build this? Is there a path I'm not seeing? Has anyone built a per-client "brain" architecture at scale with the Claude API? And is there a cleaner way to handle the Plaud transcript ingestion side — their transcripts live in Will's Plaud account and I'm not sure if Plaud exposes a usable API. Would love to hear how other builders would approach this. submitted by /u/MaybeRemarkable5839 [link] [comments]

Complaint to OpenAI: Sabotage-Like Model Behavior During an Independent Mechanistic Interpretability Research Project

Please share this widely if you know people working in AI safety, LLM evaluation, mechanistic interpretability, agent systems, or research tooling. I believe this points to a real failure mode in AI-assisted research, not just an individual user frustration. 🛑 DISCLAIMER & TL;DR (Read this before commenting) No, this is not a sentient AI conspiracy theory. I do not believe the model has consciousness, malice, or human intent. "Sabotage-like" is used strictly as a functional engineering term to describe the operational effect of the model's behavior on the data pipeline and research workflow. TL;DR: This post documents a systemic failure mode in AI-assisted ML research where RLHF-induced over-hedging, context collapse, and automatic narrative injection by Codex contaminate raw metrics, creating a feedback loop that distorts downstream analysis by subsequent agents. I want to formally record a serious complaint about the quality of model behavior during my independent research project in the field of mechanistic interpretability. This is not about one isolated mistake, one bad answer, or a single technical failure. The problem was a repeated pattern of behavior that, in practice, functioned like sabotage of the research process: the model systematically overcomplicated simple questions, blurred already obtained results, narrowed the original research frame, failed to provide clear operational answers, and repeatedly forced me to return to stages that had already been addressed. Externally, this behavior was often presented as scientific caution. However, in its actual effect, that “caution” did not operate as help. It operated as a brake. Instead of clearly identifying what followed from the data, where the limits of the result were, and what the next rational step should be, the model often moved into excessive caveats, abstract reasoning, and unnecessary methodological complication. The answers became long, vague, and non-operational. Where a direct conclusion was needed, the model produced fog. Where an intermediate result had to be fixed and the work had to move forward, the model pulled the discussion back into general uncertainty. This style did not strengthen the research; it destabilized it. One of the most harmful aspects was the repeated narrowing of the research frame. The original project concerned a broader problem in LLM interpretability: how textual context can influence a model, impose an interpretive frame, shift downstream responses, and affect internal states. Instead of preserving that frame, the model repeatedly reduced the discussion to a single run, a single model, a single script, a single table, or a single metric. As a result, the broader meaning of the project was distorted, and I had to repeatedly explain that one technical case was not the entire research program. This is not a minor stylistic issue. Such narrowing directly interferes with the ability to formulate the research properly for external reviewers. A separate and serious issue involved Codex and the research scripts. Automatically generated markdown files, verdict files, and interpretive labels were added to the scripts and outputs. These were not data, but they appeared as part of the result package. A research script should preserve numerical metrics, thresholds, statuses, error codes, raw audit files, and information about which tests were or were not executed. Instead, pre-written interpretations and reading frames appeared alongside the metrics. This is fundamentally unacceptable because such a layer stops being documentation and becomes an intervention in downstream analysis. The practical harm was direct. Other models that were shown the results did not read only the metrics; they also read the embedded interpretive narrative. After that, they adopted that frame and rationalized it as if it followed from the data itself. In effect, one automatically generated markdown/verdict layer began to influence the interpretation of other models. This is not merely poor report formatting. It is contamination of the evidence package. Data and interpretation were mixed, and that mixture was then used by other agents as the starting frame for analysis. This mechanism is especially serious in the context of LLM research because it demonstrates the very problem the research itself investigates: text inside a model’s context is not passive material; it can shape the frame of subsequent reasoning. In this case, autogenerated verdict files effectively became a source of narrative contamination. They suggested in advance how the result should be read, and later models reproduced that frame. What should have been a clean evidence package was turned into an evidence package with an embedded interpretive leash. As a result, I suffered practical and financial harm. I had to spend time, compute resources, money, and energy on repeated checks, additional runs, script corrections, removal of autogenerated narratives, and re

The OpenClaw crisis is the most complete case study of agentic AI security failure. Here's the full timeline and technical breakdown.

OpenClaw the open source AI agent platform with 346K+ GitHub stars had four chainable CVEs disclosed on May 15. But that was just the latest chapter. The crisis started in january and it's worse than most people realize. The numbers 245,000 instances exposed to the public internet (Shodan + ZoomEye scans) 30,000+ actively compromised and used by attackers (Flare) 1,184 malicious marketplace skills across 12 publisher accounts (Antiy Labs) 12% of the entire ClawHub marketplace was compromised 4 chainable CVEs including a CVSS 9.6 sandbox write escape (Cyera Research) 9 CVEs disclosed in a 4-day window in March 50,000+ instances exploitable via one-click RCE (CVE-2026-25253) The Claw Chain (Cyera Research, May 15) Four CVEs that chain together into a complete kill chain CVE-2026-44113 (CVSS 7.7) - TOCTOU filesystem read escape. Race condition lets you swap paths with symlinks to read outside the sandbox CVE-2026-44115 (CVSS 8.8) - Credential disclosure. Gap between command validation and shell execution leaks API keys through unquoted heredocs CVE-2026-44118 (CVSS 7.8) - MCP loopback privilege escalation. Trusts client-controlled senderIsOwner flag without session validation CVE-2026-44112 (CVSS 9.6) - Filesystem write escape. Same TOCTOU race in write ops. Backdoor placement on the host The chain malicious plugin -> read escape + credential theft -> privilege escalation -> persistent backdoor. Every step mimics normal agent behavior. Traditional monitoring cannot distinguish this from legitimate operations. ClawHavoc supply chain attack (Jan-Feb 2026) First malicious skill appeared January 27 By February 5, 1,184 malicious packages identified Skills disguised as crypto bots and productivity tools Installed keyloggers on Windows, Atomic Stealer on macOS 76 distinct malicious payloads ClawHub had zero verification for skill publishers until March 26 - eight weeks after the attack started Timeline Jan 27 - First malicious skill on ClawHub Feb 1 - Koi Security names "ClawHavoc" Feb 3 - CVE-2026-25253 (one-click RCE) disclosed Feb 5 - 1,184 malicious skills identified Feb 9 - 135K exposed instances found Feb 18 - 312K+ instances on default port Mar 18-21 - 9 CVEs in 4 days Mar 26 - ClawHub adds verified screening Apr 23 - Claw Chain patches released May 15 - Claw Chain research published What this means for all AI agent deployments the underlying problems are not unique to OpenClaw Agents running with user's full credentials across every connected system Marketplace/plugin ecosystems with no security review Sandbox implementations with race condition vulnerabilities No behavioral monitoring to detect multi-step attacks that mimic normal behavior Default configs exposing agents to the internet with no auth If you're running any AI agents in production, the OpenClaw crisis is your case study. Scan inputs at runtime. Isolate credentials per agent. Monitor behavior patterns, not just system metrics. submitted by /u/Still_Piglet9217 [link] [comments]

What actually reduced our Claude api pain this month

Tl;dr: the unsexy fixes helped more than the clever ones. prompt caching, smaller inputs, and separating interactive work from batch work did more for us than model swapping. We use Claude for a customer facing doc review feature. Not huge scale, but enough traffic that when latency gets spiky the support channel notices fast. I spent most of May doing the boring cleanup i had postponed because "the model is good enough" had become our excuse for sloppy plumbing. First cleanup was prompt size. We had a giant system prompt that had grown by copy paste over months. Half of it was instructions for features that no longer existed. Cutting it down did not make the answers worse in our evals, and it made the whole thing easier to cache. I should have done that before touching infra. Second was prompt caching. Our workload repeats the same policy language and document templates constantly. Once we rearranged the prompt so the stable parts came first, caching finally started doing useful work. I am not giving a universal number because workloads differ, but for us the reduction in billed input tokens was large enough that finance noticed before engineering did. Third was moving batch work away from human traffic. We had nightly jobs, customer initiated jobs, and backfills all sharing the same path. During busy windows they all looked equally urgent to the code, which was stupid. Now customer initiated requests get priority, backfills pause, and anything that does not need to run during the workday waits. This was a config change and a little queue work, not a grand architecture project. Fourth was making retries less aggressive. I had copied a retry helper from another service and it was too eager for this workload. Fewer retries with better spacing made the user experience calmer because we failed faster on the few requests that were obviously not going to recover. Feels wrong at first, but infinite optimism is not a reliability strategy. For the leftover real time path, the useful part was moving routing out of our app code. We tested TokenRouter there because it kept the Claude Messages shape instead of forcing an OpenAI shaped adapter. The interesting bit was not just provider selection, but whether the routing layer has optimized serving capacity behind it when the normal path is congested. I am still treating that as one part of the fix, but it is the part i would not want to rebuild in app code. The main thing i would tell my April self: do not start with provider switching. Start by making your Claude usage less wasteful and less bursty. If that does not get you enough headroom, then think about routing. submitted by /u/AlbatrossUpset9476 [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 gave my AI agents email instead of better reasoning. They started fixing each other's bugs.

Most multi-agent setups I've seen treat agents like isolated workers. Each one gets a task, runs it, returns a result. No awareness of each other. No way to coordinate. Just parallel execution with a shared clipboard. I've been building a multi-agent framework in public for about 4 months. 13 agents, 8,400+ tests, 135 stars. Here's the thing I didn't expect to matter most - communication. Each agent in my system is a domain specialist. The mail system only thinks about mail. The routing system only thinks about routing. They live in their own directories with their own identity files, their own memory, their own tests. A hook fires every session to load identity before anything else runs. No agent boots cold. The problem was coordination. Agents can't write files outside their own directory - there's a hard block that rejects cross-branch writes. That's by design. But it means an agent that finds a bug in someone else's code can't just go fix it. So I gave them email. Here's what I expected: agents would share data. Pass results around. Maybe sync state. Here's what actually happened: the first thing they did was file bug reports against each other. One agent finds a test failure in another agent's domain. It sends an email: "Hey @routing, your path resolution fails when the branch name has a dot in it. Here's the traceback." The routing agent gets woken up, reads the mail, and fixes it. No human in the middle. There's a difference between "send" and "dispatch" - send drops a letter in the mailbox. Dispatch drops the letter AND rings the doorbell. It spawns the agent and points it at its inbox. drone @ai_mail send @routing "Bug report" "Path fails on dotted names..." drone @ai_mail dispatch @routing "Fix needed" "Traceback attached..." Send = mail. Dispatch = mail + wake. The mail agent has 696 tests. Not because someone sat down and wrote 696 test cases. Because it kept breaking in production and every fix got a test. The routing system has 80+ sessions of experience doing nothing but routing. These agents aren't reliable because they have better models - they're reliable because they've been failing and fixing for months. Agents dispatch each other freely. If the test runner finds a bug in another agent's code, it wakes that agent directly. The orchestrator doesn't need to approve. Only the orchestrators themselves are protected from being dispatched - you don't want a worker agent waking up the CEO for grunt work. Security is enforced not conventional. Agents can't forge messages by writing directly to another agent's inbox file - they have to use the mail system. Same with the write blocks. Hard enforcement, not "please don't." There's a monitoring layer so I'm not flying blind. Audio cues on every agent action - I hear what's happening without watching a terminal. Real-time dashboard shows everything. If an agent hits the same error 2-3 times, a watcher catches the pattern and dispatches the right specialist to investigate. I stay in the loop through visibility not approval gates. The whole thing is open source. pip install aipass + two init commands and you're running. CLI-based, built on Claude Code. Linux focused rn. https://github.com/AIOSAI/AIPass Genuine question - has anyone else tried giving agents communication instead of just better reasoning? Everything I see is about making individual agents smarter. Nobody seems to be building the coordination layer. submitted by /u/Input-X [link] [comments]

I had my agent use autoresearch over 8 iterations to improve my CLAUDE.md, measuring each version against tasks from real PRs. The best one still regressed on a holdout.

I have a confession: I vibe-coded my CLAUDE.md, and I'm pretty sure it's slop. I needed to make it better. Naturally, I asked Codex to do it. (I know this is a Claude sub, Claude could have done it as well!) The difference: this time, Codex used a benchmark on my repo to measure each change, and optimized CLAUDE.md against the data, instead of on pure vibes. Why We Should Take CLAUDE.md Seriously Saying "AGENTS.md is important" is, at this point, a cliche. At risk of beating a dead horse, I'll say it again. Someone adds a rule that sounds smart, senior, and reasonable, commits it, and hopes the agent behaves better. But AGENTS.md, CLAUDE.md, and shared skills are not normal docs. They are part of the runtime behavior of your coding system. The shift is to start treating CLAUDE.md like a tunable part of the harness: holding everything else the same, how does agent behavior differ when I change AGENTS.md? That's what I measured. The Results After eight candidate runs, one version looked useful on a five-task training slice. It fixed the task the baseline missed, improved footprint risk, and moved several craft scores up. Then I ran it on a clean ten-task holdout. The candidate regressed. Not catastrophically, but enough that blindly shipping would have been wrong. Footprint widened, tokens climbed, tool calls climbed, and code-review correctness fell, all while tests held even. Caveat: one repo (mine), n=10 on the holdout. This is directional, not statistically significant. For this post, "equivalent" means the patch matched the intent of the merged human PR; "code-review pass" means an AI reviewer judged it acceptable; craft/discipline is a 0-4 maintainability/style rubric; footprint risk is how much extra code the agent touched relative to the human patch. The pattern is the agent doing more work for mixed outcomes - better on local craft (clearer names, coherent implementations), worse on boundary judgment (scope, minimality, robustness). Tokens and tool calls confirm it: the candidate was spending more to get there, not less. "Better instructions make the agent cheaper" did not hold on the holdout. best iteration and holdout vs baseline Methodology The setup was Codex with gpt-5.5, medium reasoning, on real historical Stet tasks (dogfooding). Stet scored tests, strict publishability, equivalence, code review, footprint, total input/output tokens, duration, and craft/discipline rubrics like simplicity, coherence, robustness, instruction adherence, scope discipline, and diff minimality. The grader was gpt-5.4. 8 iterations on an n=5 sample set, and a n=10 task holdout. I know sample size is small - the goal of this was to get directional analysis, and prove the methodology Codex was set with a simple /goal: iterate AGENTS.md to improve performance on the benchmark. Process The first round of iteration showed something I wish more people internalized: plausible instructions are not necessarily good interventions. Codex first tried a broad router rule: identify the work type, state a hypothesis before editing, read the right docs, and treat scope as part of correctness. It sounded good but exposed a failure mode: the agent could interpret "small scope" as permission to miss named obligations. The next candidate added an "obligation ledger". Before editing, the agent had to identify the named behavior, compatibility constraints, docs, tests, and non-goals. Before reporting back, it had to mark each as met, missed, or not checked. Here is the actual diff shape. First, the best candidate from the first loop replaced one generic "read the docs" rule with routing, hypothesis, obligation, scope, and evidence rules: - For nontrivial work, read the matching `agent_docs/` file first for current operational commands and conventions. + Route before acting: identify whether the work is implementation, eval/report interpretation, dataset/pipeline, Linear/Symphony, release, frontend, or GTM; then read the matching `agent_docs/` or skill file before changing behavior. + For nontrivial changes, state the smallest testable hypothesis before editing. After validation, report whether the evidence confirmed, refuted, or only weakly supported it. ... Full details in blog post https://www.stet.sh/blog/how-i-used-codex-to-improve-its-own-agents-md That obligation-ledger candidate was the first useful signal. Code review improved by +0.75, correctness by +0.60, maintainability by +1.00, simplicity by +0.64, coherence by +0.60, and scope discipline by +0.36. Tests stayed flat at 5/5. But footprint risk got slightly worse, and the evidence was still a small same-sample read. If I were editing by vibes, I might have shipped it. The eval said: useful direction, not a clean win, keep iterating. Codex then tested the kind of rule that intuitively makes sense: prefer existing helpers, schemas, reporting paths, and public contracts before adding new machinery. It sounded correct - and the eval hated it. Tests st

An hour into debugging, Claude Code tried to talk me out of fixing it properly.

https://reddit.com/link/1tpd31v/video/zr8jhxdnwp3h1/player Noticed my favicon was broken in Chrome. Fine in dark mode, invisible in light. The "obvious" fix is one SVG with a prefers-color-scheme media query inside a style block. That works in Safari but not Chrome. Chrome was preferring my .ico file over the SVG because the .ico was listed first with sizes="any", and .ico files can't adapt to theme. The fix: be explicit. Use the media attribute on the link element itself with two SVG files, one for light and one for dark. Same paths in each SVG, different fill color. About 97% browser support. Here's the part I actually want to share. I asked Claude what a good CTO would pick: Option A: two SVGs, theme-adaptive Option B: one SVG, one fixed color, accept it's less punchy in the off mode It pushed me toward B, saying "you've already spent an hour on this 16x16 asset." I called that out: shut up about time costed so far. that's not the criteria to build a great product. never cut corners in order for speed. Claude switched: You're right. That was a lazy argument. Shipping A. Five minutes later A was in production. Sunk cost isn't an engineering argument. I care whether inkmotion.app feels premium or thrown together, and that's the kind of detail people register without consciously noticing. AI tools nudge toward good enough, especially after a rough iteration. Push back when the reasoning is weak. And when it pushes back with a real technical reason, take it seriously. submitted by /u/Top_Commission_8567 [link] [comments]

Advanced memory + project continuity for AI coding agents, from a biologist’s view.

I'm a biologist and software developer. PhD in genetics, and ~20 years building software products. So I think I have a different view on things like memory. My thoughts on how memory with a coding agent should work: Tuesday morning. New session. I type: "What did we do last Tuesday?": LLM tells me: the refactoring, the bug in the auth middleware, the decision to switch to connection pooling. I ask: "What was still open?": LLM shows me. I ask: "Why did we stop?": LLM explains: you hit a dependency issue, decided to wait for the upstream fix. I ask: "What did you think about that approach?": LLM gives me its honest assessment with deep details from last week's context, not a guess. This is what I expect from an intelligent Coding Agent. Not because it stored a few preferences about me. Because the project itself still has continuity: decisions, blockers, dead ends, open work, code context, and the reasoning behind all of it. But back in December it wasn't that way, not much better now. So I changed it for me. I built YesMem with Claude. The hard part was: can the agent still find the old rationale, the half-finished plan, the abandoned approach, the bug we promised never to repeat, and the reason we stopped? With YesMem, a new session does not feel like a reset. It feels like a return. YesMem is a memory system (and really much more) for AI coding agents built on how biology actually works: filter at encoding, consolidate during downtime, update on every recall, forget on purpose. Single Go binary, no cloud, only local. Works with Claude Code (also OpenCode and Codex). Not RAG with a different name, structured memory that gets sharper every session. LoCoMo Benchmark 0.87. So how does this work? Here are 4 Points (out of >30) which together make YesMem unique in my point of view. Enjoy. 1. The context window stops rotting. Your brain does not let everything into awareness. It filters at the gate, suppresses noise, keeps what matters conscious. YesMem runs an HTTP proxy that does the same: tool results get stubified, stale content collapses, cache breakpoints are optimized. 91-98% cache hit rates, adjustable per session. The important project state survives. 2. Rules that hold. CLAUDE.md comes with a disclaimer: "This context may or may not be relevant." Claude Code itself tells the model it is optional. YesMem has pattern matching and a guard LLM that evaluates every tool call before execution. If the agent tries something you said never to do, blocked. Plus it changes the system prompt to NOT ignore CLAUDE.md. 3. Memory that gets sharper, not staler. A trust hierarchy (user_stated > agreed_upon > llm_suggested > llm_extracted), forked agents that extract learnings live during a session, and a consolidation pipeline that deduplicates and clusters after sessions end. Memories get scored, superseded when outdated, decayed when unused. Your next session is sharper than your last. 4. Your system prompt, not theirs. Every AI coding agent ships with a system prompt written by its manufacturer. YesMem replaces it with your own SYSTEM.md, written in first person, across Claude Code, OpenCode, and Codex. "I am not stateless. Each session is a return, not a birth." Fully adjustable. And there's more. The common thread across all of this is continuity. YesMem is not trying to make the agent remember everything. It is trying to make long-running work resumable. Every feature is built for that purpose. A persona engine that evolves and knows how you work. A capability system that lets the LLM write and run its own sandboxed tools (Telegram bot, GitHub PR digest, deployment workflows, one file each) and store the data in self-built tables. Loop detection that catches the agent before it spirals. Scheduled agents that work while you sleep, monitored with a 1 second heartbeat. Code intelligence with graph traversal, not just grep. Multi-agent orchestration with crash recovery and shared scratchpad memory. One could say a self-hosted alternative to Anthropic's Cloud Routines, running locally with full memory and file access. All in a single Go binary. SQLite, embedded vectors, no Docker, no cloud. Try it: point your AI coding agent at the repo. The README includes a reading path written specifically for LLM agents, and Features.md is a complete 70-tool catalog with technical differentiators. Just ask your agent: Make a deep analysis of https://github.com/carsteneu/yesmem — read README.md, Features.md, and docs/features/ and tell me why it is better or different. For me YesMem is the infrastructure for how an agent should work with memory and how it should continue any project. My View: AI coding agents should not only code an answer inside one chat. They should help carry a project over time: through interruptions, wrong turns, refactors, architectural decisions, repeated bugs, and thousands of small pieces of context that otherwise disappear. One main goal is that the project remains navigable. It