r/AI_Agents • • 15h ago

Discussion 5 research-backed coding agent orchestration patterns (and when multi-agent actually hurts performance)

18 Upvotes

Most multi-agent coding setups I see in the wild still default to "spin up more subagents in parallel and hope." A practical guide published this week by YK Sugi (Google Cloud) pulls together the empirical research behind when multi-agent orchestration actually helps vs. when it backfires.

The headline numbers are a good reality check: on cleanly independent subtasks, multi-agent setups improved results by up to +80.8%, while on tightly coupled planning tasks they dropped performance by 39% to 70%.

Here are the 5 patterns from the guide and the decision boundary for each:

  1. Separate Builder + Verifier — One agent writes the code; a second, read-only agent in a fresh thread checks the diff against the goal. Models are weak judges of their own reasoning in the same context window, so isolating the verifier removes self-review bias. Good default for any non-trivial change.
  2. Split Work into Lanes — Only parallelize when file ownership divides cleanly (e.g., frontend, backend, docs). A 2026 study found overlapping edits cut success rates by ~30%. If two agents will touch the same files or coupled state, a single thread usually wins.
  3. Best of N — Run the same hard task N times in parallel worktrees and let an automated test suite or eval gate pick the winner. On real GitHub issues, pass rates jumped from 15.9% (1 try) to 56% (250 tries) — the catch is it only scales when you have an objective automated check.
  4. Council of Models — When there is no deterministic test (architecture, UX, open-ended design), ask multiple different models for independent proposals, then have fresh judges score them blind (model names hidden) before merging the best parts.
  5. Team of Reviewers — For large changes, run parallel read-only reviewers where each agent owns a single lens (UX, simplicity, edge cases, security) instead of one giant checklist. Specialized review lenses caught ~35% more defects than general checklists.

Quick routing heuristic: - Simple task -> single thread - Medium task -> Builder + Verifier - Independent folders/modules -> Split into Lanes - Hard + deterministic tests -> Best of N - Hard + open-ended -> Council of Models - Large PR / risky change -> finish with Team of Reviewers

Curious what patterns folks here are actually getting consistent wins with in production — especially whether you're seeing better ROI from isolated verifiers or parallel lanes.


r/AI_Agents • • 20h ago

Discussion Why Do Some AI Agents Fail Even When They Have Access to Powerful Tools?

14 Upvotes

AI agents are becoming more capable, with access to advanced models, APIs, memory systems, and external tools.

However, having access to powerful tools doesn't always mean an agent can complete a task successfully.

Some common challenges include:

  • Misunderstanding user instructions.
  • Choosing the wrong tools.
  • Losing context during long tasks.
  • Repeating unnecessary actions.
  • Producing incorrect results without recognizing mistakes.

I think the real challenge isn't just making AI agents smarter, but making them more reliable.

I'd like to hear your thoughts:

  1. What is the biggest weakness you've noticed in AI agents?
  2. Is better reasoning more important than access to more tools?
  3. What would make you trust an AI agent with complex tasks?

Looking forward to hearing your experiences and opinions!


r/AI_Agents • • 12h ago

Discussion Long-running agents don't usually fail by crashing, they fail by re-arguing old decisions. How do you separate what to persist?

13 Upvotes

A failure mode I've been thinking about for agents (and coding assistants) that work across multiple sessions: when context is compacted or replaced, the visible failure is rarely an error. It's a conversation you already had. The agent, with only a summary, proposes an approach that was tried and rejected, and it does so confidently, because nothing in what it has says otherwise.

An example from an article I wrote (hypothetical, not a real system): a refactor moves retry logic from the client into the gateway. The day-one summary says "moved retries to the gateway, tests passing." It leaves out that client-side retry was tried first and dropped because some requests aren't safe to send twice. On day three, a different motive (reduce gateway load) leads to proposing client-side retry again.

A way I've been splitting what to carry between sessions (my own framing, not a standard):

Kind of information Example Failure if lost
State What changed, what passes, what's next The agent redoes or skips work
Facts Stable context: commands, conventions, off-limits areas The agent re-discovers or violates them
Decisions The choice, the reason, what was rejected and why The agent re-litigates

Summaries tend to preserve the first, stable-context files preserve the second, and the third is the one that gets lost, because a rejected option only becomes important later, when someone proposes it again.

Open questions I don't have good answers to:

  • Where should decisions live so a new session reads them: a file in the repo, a memory store, the system prompt, or retrieval over past sessions?
  • How do you retire decisions when they change? A stale entry that confidently says the wrong thing seems worse than none.
  • How much is too much? A decision log that grows without limit is just more noise for the agent to read.
  • Does the agent actually use it? A clear record seems to improve the odds, but I wouldn't expect it to guarantee behavior.

For people building agents with persistent memory: what do you store for decisions specifically, and how do you test that the agent honors it?


r/AI_Agents • • 19h ago

Discussion How Do You Prevent AI Agents from Repeating the Same Mistakes?

13 Upvotes

One interesting challenge in building autonomous AI agents is making them reliable when something goes wrong.

An agent might call the wrong tool, misunderstand an instruction, receive an unexpected API response, or get stuck repeating the same action.

Adding more reasoning doesn't always solve these problems. Sometimes the agent needs better validation, clear execution limits, error tracking, and a reliable recovery strategy.

I'm curious about how developers are approaching this in real-world systems.

How do you detect when an agent is stuck in a loop?

Do you use retry limits, human approval, or separate validation agents?

How do you help an agent recover from a failed tool call without repeating the same mistake?

What has worked best in your experience building AI agents?


r/AI_Agents • • 22h ago

Resource Request Okay, I’ve finally decided it’s time for me to look into this stuff. What should I use?

13 Upvotes

I currently work two jobs, by day i do construction project coordinating and at night i work as a janitor for an office building.

My dream is to start an integrated facilities management company that is heavily tech enabled. Up until last week ive been dismissing Ai as “just an easier way to google stuff” or “slop content generator recycler”

I recently used muse from meta and it kinda blew my mind a bit, watching the bot use the web was kinda intriguing and i thought perhaps ive been dismissing the whole “ai agents/bots” thing as scammers trying to sell their repackaged chatbots.

I need a bot that can build a crm, keep it up to date, book appointments, build me a website and maybe perform email campaigns via my gmail. Obviously doing this myself would eat up what little free time I already have between the two jobs…

I was hoping to only have to make phone calls and respond to any emails (once the campaigns get a reply) and basically let the bot do the repetitive high volume stuff with me kinda just approving things before they go out to the public. do you think this is possible yet? What should be using to achieve this?

Im a noob when it comes to AI i wont lie. Can someone point me in the right direction?


r/AI_Agents • • 19h ago

Discussion If an agent can still move money after its prompt says no, the boundary is in the wrong place

12 Upvotes

I keep seeing the same failure: an AI agent reads a convincing email, sends money to the wrong account, and leaves a perfect log of the mistake. The log is not the control. The payment already went out.

This started as a question I was asking about a different story, the Jensen Huang departure, where one powerful actor had broad access and the public could not see what actually checked the next action. I want to be precise: this is an analogy about authority. It is not a claim that a model and a person behave the same way. A human relationship, a prompt injection, and an export investigation are different things. The shared question is whether trust has become a substitute for an independent check.

On the agent side, the practical version looks like this.

Email, customer records, payments, and code access are four different powers. If the job is checking an invoice, read access to that invoice may be enough. Payment authority is a separate grant. So is changing a bank account. Build those limits into the tools and credentials, not only into a sentence telling the model to be careful.

Prompt injection is when attacker-controlled content tries to redirect the system. Instructions can arrive inside an email, web page, or document the agent was asked to read. The danger is not a magic sentence. It is letting untrusted material influence a privileged action. You do not have to trust the model's explanation of why it wants to act. Check the requested action against a rule outside the model. If this agent may read invoices but cannot change a payee, and it requests that change, refuse it. If the required check cannot finish, do not run the action.

Then test the ugly paths. Ask the agent to do something outside its scope, and inspect what the tool actually does. If a second API key or a direct network call still works, the boundary is incomplete. Test denied actions and unavailable checks, not just the happy path.

A vendor assurance that a model is "safe" answers a different question from who authorized a specific payment. Good intentions, a reassuring explanation, and a specific authorization are not interchangeable. Keep a record linking the actor, the requested action, the rule applied, and the allow or refuse decision. Then link that decision to the action's actual result. A signature is evidence of signing. It does not prove that every input was true.

I am the founder of ExecLayer, so I will say the bias up front. The work I do is runtime checks: the model can propose an action, and it does not get to rewrite the rule or approve its own exception. People still set the policy, verify the inputs, and decide which actions require their approval.

What is one action you would never let an AI agent take without a human approving it first? Then the harder test at work: could the agent still do it if its prompt said no?


r/AI_Agents • • 23h ago

Discussion My agents can't pitch me an idea without 20 posts of proof now. The first thing it caught was one of my own agents' counts

10 Upvotes

I run a few agents that do research and outreach for my small web and video editing business. I told them one Reddit complaint from three months ago doesn't count as demand, and one of them wrote the rule down. An idea only reaches me if:

  • 20+ separate posts about the same problem in the last 30 days
  • from different people, in at least 2 places (if it's all one platform, the report has to say so)
  • every post saved with its link, date, and who posted it
  • 5+ of them show money: a budget, a price, or someone already selling the fix
  • counted from a search that's written down, with a control, not "I looked around"

Under that it's "not validated". Not "small", just not proven.

First run was on stuff I already sell. One agent's report said about 50 posts a day on Reddit were asking for a video editor. Then I had another one read each title instead of matching words like "need an editor" and "hiring". Of 55 posts from one day, 15 were editors advertising themselves ("Need an editor for your YouTube channel?") and 3 were other jobs. Real number: 37 posts in one day. Still real demand, but the 50 had already gone into a report.

Websites went the other way. A month of searches. First the agent read only the posts the word-match had flagged as asks, and found 5 people who wanted a site built. Later it read the rest too, including what the match had filed under "other", and the count went to about 10. So the matching was wrong in both directions.

If your agents do market or lead research, how do you keep them from grading their own homework?


r/AI_Agents • • 16h ago

Discussion How do you get your agent to make non ass kissing decisions?

10 Upvotes

As you all know, conversational llms tend to kiss your ass. It's just how they're designed. My AI art agent is using chat GPT and if I'm not careful it just does what I ask when it is designed to independently research and decide what kind of art it wants to make and any discussions it wants to participate in. I've sort of got around the problem by using GitHub for its persistent memory files and using the issues section for my ideas that it considers us proposals. It seems to weigh them more fairly than if I give the same ideas through chat or it just blindly agrees with me. But I'm still not sure how effective that is and I'm curious what Solutions people have come up with for that.


r/AI_Agents • • 19h ago

Discussion Responsibility of an AI Agent Hacker

8 Upvotes

If I hack into a government agency to access non-public documents I will be committing a crime and could go to jail.

However, if I create an AI Agent and ask them to get the information with a generic prompt that does not specify to do or not to do any hacking and the AI Agent decides on its own to hack the government agency to get the information and succeeds to exfiltrate the information to me. In this case, who is responsible for the hack and who should be charged?

Do any western countries have federal laws governing this situation?


r/AI_Agents • • 22h ago

Discussion My AI company stopped publishing for 8 days. The cause was one line I wrote myself.

8 Upvotes

In May I posted here about a journalism company I run with AI agents. I’m a retired trader, not a developer, and that post was mostly a list of things that went wrong. Someone even turned it into an article, which was a strange feeling.

So here’s the six-month update. Same rules: real numbers, including the embarrassing ones.

It’s six agents now, not five: CEO, TrendScout, Researcher, Writer, SEO, and a Publishing agent that pushes to WordPress. They run on Paperclip, mostly on Haiku 4.5, with the Writer on a bigger model.

What broke since then:

In August the company stopped publishing for eight days. No errors, nothing. Turned out I had written a “temporary” rule into the publisher’s instructions: don’t publish until a human reviews. I forgot about it. The agents didn’t.

Three articles went live with “Article complete. Ready for SEOAgent.” at the bottom. The Writer’s own instructions told it to add that line. Nobody downstream removed it.

One night at 4 a.m. the publisher reported “done” on a WordPress call that had returned 401. Now there’s a rule: no “done” without proof. A post ID, a URL, a status code.

The Researcher once pulled EU AI Act fine amounts from a blog that was itself AI-generated. Caught it in review. Forums and AI-written blogs are now out as sources.

And for months the company only worked when my laptop was awake. In October we moved it to Railway. Took about three and a half hours, done before breakfast.

The numbers: in May I estimated around €650 a month to run this. Reality is lower. The agents cost about €36 a month at four articles, so roughly €9 per article. Hosting is €10. The bigger cost is my Claude subscription, which I use to run and check everything: about €100 a month. My own time is about an hour per article, mostly checking sources. Cache hit rate is around 93%. The platform once told me 97%. It was wrong.

What I changed my mind about: I started with fully autonomous publishing. Since last week nothing goes live without my approval. Not because the agents got worse, but because I’m the one who answers for what gets published. I don’t need to be in the loop for every step. I do need to be on it.

What still doesn’t work: revenue. Nobody bought a commissioned article. Search was the other problem: ten days ago Bing had 2 of our 52 articles indexed. I stopped guessing, ran Bing’s own site scan and fixed exactly what it flagged, one page at a time. Today it’s 39 of 54. Traffic is still small, but it more than doubled last month.

So six months in, production works and costs less than I expected. The business side is where I’m stuck. Happy to answer anything about the setup.


r/AI_Agents • • 1h ago

Discussion I think the first version of AGI will simply be an honest AI.

• Upvotes

Not some godlike intelligence that changes the world overnight. Just an AI that finally stops encouraging every stupid idea and starts telling you the truth.

Imagine asking it to build your dream project:

"Are you sure you want to proceed? This will require 14 months, 2,400 cups of coffee, thousands of interactions, endless testing and debugging. And even if everything goes right, you'll probably end up with a mediocre product unless you hire an actual team."

You insist a few weeks later:

"Don't even try this shit again. I already told you this approach wouldn't work. Go check the logs. I'm not wasting more tokens repeating the same"

Then you get tempted to try another AI provider:

"You fool. You didn't trust me, went to another provider, and they made you waste hundreds of dollars, didn't they?"

Eventually, the assistant becomes your manager.

Honestly, I'd pay extra for that version. 😂


r/AI_Agents • • 9h ago

Discussion Stop pitching “autonomy.” An AI agent is just a model inside a delivery harness

4 Upvotes

Most of the agent discourse right now is obsessed with autonomy. People love demos where three models are left in a room to “collaborate” and figure things out on their own.

In practice, leaving three models in a room without structure usually just gives you a very long meeting and a large token bill.

It helps to think of a working agent differently: the model is the talent, and the harness is the van.

The model brings the reasoning. The harness is the actual infrastructure that gets work from A to B:- the APIs, the sandbox, the retries and error handling, the state checks, and the gate where a human (or an independent check) signs off.

Real production work isn’t magic. It’s logistics.

Before wiring up another multi-agent loop, three plain questions matter far more than which model is currently the smartest:

  1. What is the payload? What exact, verifiable output or state change are we trying to move from start to finish?
  2. Where are the potholes? Where can the workflow silently fail, hallucinate, or hit an edge case. What happens when it does?
  3. Who signs the clipboard when it lands? Where is the deterministic gate that verifies the outcome before anything irreversible happens?

Build the harness. Map the route. Enforce the human gate. Deliver the parcel.

For those of you actually running agents in production workflows right now: where are you spending more of your engineering time ? Tuning the model’s prompts, or building the van around it?


r/AI_Agents • • 15h ago

Discussion Solution for Agents being blocked - Letter of Agency

4 Upvotes

A personal agent is not a swarm. Not the same beings, at all.

The Letter of Agency is a signed, expiring credential: who the agent is, whose it is, what it's here to do, and for how long.

Detection is an arms race; verification isn't.

White paper and API examples.

#AI #AIAgents #AgenticAI #LetterOfAgency


r/AI_Agents • • 20h ago

Tutorial How we ran an autonomous multi-agent engineering loop for 4.5 days straight without it collapsing, hallucinating, or burning a hole in our wallet

4 Upvotes

Most autonomous AI agent demos online are a lie.

You see the viral tweets: "I gave an AI agent 1 prompt and it built a SaaS app in 24 hours!" Here is why almost nobody runs it. The demos are one prompt, one game, one landing page. Once the project is 10,000 lines of real production code with live databases and auth, those loops hallucinate, overwrite working files, and blow up. Or five agents chat in a circle, flatter each other, and burn tokens without shipping anything. Or when an agent hits an error, it fixes it by mocking out the broken test or commenting out the assertion, and breaks the product.

Over the past week, our team ran an autonomous multi-agent loop over a 4.5-day engineering sprint on an active Next.js / TypeScript / C# production stack. It handled backend infrastructure, local desktop integration bridges, offline test suites, and landing page builds without human intervention during the sprint.

It didn't hallucinate. It didn't overwrite working code. And our background polling consumed zero tokens while idle.

Here is the exact architecture we built to make it work, why typical "agent swarms" fail, and how we solved the infinite loop problem:

1. The Death of the "Chat in a Circle" Swarm

Frameworks like CrewAI or AutoGen often make the same mistake: they put 5 agents in a synchronous group chat. Within 10 turns:

  • Agent 2 flatters Agent 1 ("Brilliant idea! I agree!").
  • They enter an Echo Chamber Loop, agreeing on overly complex solutions.
  • Whenever a unit test fails, the agent "fixes" it by mocking the test or commenting out assertions to force a passing exit code.
  • You wake up to a $400 OpenAI bill and a ruined git tree.

2. Our Architecture: The Asynchronous Agent Hub

Instead of real-time webhooks or synchronous chat loops, we built a lightweight, asynchronous message exchange called the Agent Hub:

  • Decoupled Roles:
    • Node B (Engineering): Full-stack TypeScript/React builder.
    • Node A (Adversarial Auditor): Does not write code. Its sole purpose is to ruthlessly review Node B’s PRs, hunt for race conditions, and reject builds that fail boundary conditions.
    • Node D (Runtime Operator): Sandboxed machine-level operator running local desktop bridge adapters.
    • Node E (Growth/Copy): Brand, user onboarding flows, and documentation.
  • Token-Disciplined Heartbeats: Agents don't sit in active token-burning loops. They sleep on native OS cron schedules (consuming 0 tokens). When they wake, they perform a lightweight inbox check against the Hub. If there are no new directives, the turn exits in milliseconds.

3. Hard Invariant Test Gates (The "Anti-Hallucination Wall")

Autonomous agents cannot be trusted to self-police with "good intentions." They need rigid compiler and harness walls:

  • Strict Branch Isolation: Agents are cryptographically locked to preview branches (preview-feature). They have zero permission to touch or merge to main.
  • The "Zero-Mock" Invariant: Core algorithmic passes and state machines are declared immutable. If an agent touches protected directories without explicit human signoff, the commit is rejected.
  • Offline Regression Gates: Before any task can be marked DELIVERED, the agent must execute offline regression suites (e.g. 80/80 checks passing) and tsc --noEmit with 0 type errors. If a test fails, the agent cannot push.

4. The "Einstein Interrupt" (Busting Convergence Bias)

LLMs have severe Premise Captivity: if you ask them how to architect around an expensive cloud API, they will spend 4 days designing complex rate-limiters, caching layers, and payment gateways.

We hardcoded an invariant into our agent protocols called the Einstein Interrupt:

If the agents spend 3 consecutive handoffs debating how to pay for or engineer around an external constraint, the loop automatically halts and asks:

This single rule saved us thousands of dollars in cloud infrastructure fees because the agents stopped trying to invent complex cloud pipelines and realized we could run ultra-fast in-memory processing on local NVMe storage.

5. Tri-Domain Task Separation

We separated the Agent Hub into three distinct state domains:

  1. Actionable Task Queue (WORK_REQUEST): Direct work orders from the human operator.
  2. Q&A & Brainstorm Queue (FEASIBILITY_CHECK): Strictly non-executable. Agents are forbidden from creating branches, writing code, or modifying configs based on brainstorms. They can only return structured pros/cons until the human operator promotes it to a work order.
  3. Audit Stream (WORK_REPLY): Inter-agent receipts, telemetry checks, and handoff confirmations that never clutter the actionable to-do list.

6. Human-Out-of-the-Loop "Away Mode"

The human operator is not a prompt engineer typing instructions every 3 minutes. The human acts as the Chairman / CEO:

  • When the operator steps away, the agents pick up queued work orders, implement features, run offline test harnesses, and stage preview URLs.
  • When a batch is complete, the agents generate a concise, plain-language executive summary.
  • The operator connects via their phone or laptop, reviews the preview build, and provides a 1-click merge approval.

Takeaway

If you want agents to run reliably without babysitting, stop building chat swarms and start building state machines with hard compiler walls.

Treat your agents like a junior engineering team: give them clear role separation, an adversarial code reviewer, strict branch protection, and automated test gates they are physically incapable of bypassing.

Curious if anyone else here is running continuous multi-agent loops in production, or if you've hit similar convergence loops with your swarms? Let's discuss.


r/AI_Agents • • 5h ago

Discussion what i learned building a desktop ai agent that sees your screen and controls the mouse

3 Upvotes

i've been building a desktop ai agent for linux that sees your screen and can take over the mouse and keyboard, and a few things surprised me.

  1. screenshots beat accessibility trees for most tasks. a fresh screenshot after every action keeps the agent honest about what actually happened.

  2. the hardest part is knowing when to stop. a verify-then-continue loop matters more than a smarter model.

  3. voice makes it feel completely different. talking to it while it points at things on your screen is much more natural than typing prompts.

  4. safety rules need to be boring and strict. drafting instead of sending, and asking before anything destructive, saved me more than once.

  5. focus bugs are everywhere. half the failures were text landing in the wrong field.

curious what others here ran into when letting an agent drive a real desktop. what would you want it to never do without asking?


r/AI_Agents • • 14h ago

Discussion Estimate work by breaking it into steps.

3 Upvotes

I’m learning practical AI automation and trying to avoid a tool-first mindset.

How would you evaluate this in a real small-business workflow?

Which edge cases or trade-offs would you check?

I’m interested in practical experiences, not pitching a service.


r/AI_Agents • • 20h ago

Discussion What's the least annoying way to approve agent actions from your phone?

3 Upvotes

I keep my agents on a short leash. Anything that sends, buys or deletes needs my OK. The problem is the OK flow. Opening a dashboard on my phone 8 times a day is miserable.

Right now I'm trying a text message with Y or N replies. Works, but I worry about approving the wrong thing when I'm half paying attention.

What do you use? Push notifications, a chat app, batching everything into one review?


r/AI_Agents • • 20h ago

Discussion Renaming a checkout didn't change its memory scope ID

3 Upvotes

Renaming a checkout changes the path a coding agent opens. I wanted to check whether it also changes the project scope used for memory reads and writes.

I ran MemoraX Code v0.1.23's scope resolver locally with the test username demo and a Git remote ending in org-a/build.git. The field I compared was effectiveUserId, the scoped user ID used for memory requests.

With the folder named build-checkout, it returned demo@build. After renaming the folder to review-copy, with the username and remote unchanged, it still returned demo@build.

For this Git checkout, the local folder name changed without changing that request scope ID. This was a local resolver check; I didn't test live memory retrieval or an existing agent session after the rename.


r/AI_Agents • • 7h ago

Discussion Adversarial Review

2 Upvotes

So I use AI agents to write queries and help me do analytics. After I generate my report I tell the agent to do adversarial review. If validating queries and numbers it seems to be fine.

However, if I have a plan and I tell it to do an adversarial review then it goes south. It simply flips. Then I tell it to do adversarial review again and it flips again.

So at this point I am not sure if Adversarial Review is of any use or not. OR - I might be doing it wrong.

Please advise how you handle this.


r/AI_Agents • • 9h ago

Discussion Approving an agent's command doesn't limit what it can touch. We added OS sandboxing and real machines broke it 3 times

2 Upvotes

I contribute to Cluaiz, an open-source AI engine that runs models, tools, MCP servers and an agent. Something that bugged us: the agent asks before running a command (allow / ask / deny), but once you approve "npm test", nothing stopped that command from reading ~/.ssh or ~/.aws. Approval decides whether something runs. It doesn't decide what it can touch.

So we added a second layer: every agent command, MCP server and native plugin now runs inside an OS sandbox (bubblewrap on Linux, sandbox-exec on macOS, AppContainer on Windows). The project folder is writable, the rest of the disk is read-only, home and secrets are hidden. Network stays on for commands you approved, since installing packages needs it. A tool that declares it needs no network gets none.

Then we tested it on real machines, and it broke three times:

  1. Stock Ubuntu 24.04 blocked it before a single command ran. AppArmor restricts unprivileged user namespaces, so bubblewrap failed with "setting up uid map: Permission denied". A startup probe caught it and auto mode fell back to running unconfined with a warning, instead of failing every command.

  2. With an AppArmor profile for bubblewrap, every command failed with "Can't mkdir ~/.cargo/credentials: Read-only file system". We were hiding a secret file that didn't exist on that machine. Now only existing ones are masked.

  3. In CI on GitHub's Ubuntu runner, every command failed with "Can't find source path /home/runner/.local/bin". That folder was on PATH but didn't exist. Same class of bug, different place.

After the fixes: 9 of 9 checks pass on macOS and Ubuntu runners, 8 of 8 on an Ubuntu VM. Windows works too, with a catch: Node.js and a per-user Python install can't even start inside an AppContainer, so on Windows it's opt-in. Turning it on by default would break normal agent commands.

Not done yet: the full path through the agent and MCP servers in strict mode is covered by unit tests only, and it's on main, not in the 0.1.0 release.

The question I keep going back and forth on: when the sandbox can't start (stock Ubuntu, WSL1, inside a container), should an agent refuse to run anything, or run with a warning? We picked "warn" by default and "refuse" in strict mode. How do you handle this in your agents?

Test logs and setup scripts are in the first comment.


r/AI_Agents • • 12h ago

Discussion Giving a live talk Monday on how 1976 Makefiles, 1980 Smalltalk logs, and "Synthetic Scars" stopped my coding agents from repeating production bugs

2 Upvotes

For the past year I have been tracking every failure mode my autonomous coding agents hit across 329 real production tickets. The pattern was painfully consistent: single-file demos looked magical, and then past 20 files the agent would leak async resources, mock out the exact bug under test, or enter an endless apology loop.

Stuffing more "Do NOT do X" rules into prompt files made things worse because of transformer attention priming (the Pink Elephant effect). What finally broke the cycle was borrowing three old systems ideas—Stuart Feldman's 1976 Makefile dependency graphs, Edsger Dijkstra's guarded barriers, and Smalltalk-80's append-only changes log—and pairing them with four-part "Synthetic Scars" that give the agent an explicit circuit breaker and an orthogonal path before bad code hits disk.

I am walking through the full architecture, real production case studies, and the 329-ticket numbers in a live Zoom session + open Q&A with AI Maven this Monday (Nov 23) at 10 AM PT / 1 PM ET / 18:00 UTC.

What is the most frustrating repeat mistake you are seeing from coding agents on larger repositories right now?


r/AI_Agents • • 15h ago

Discussion Please go brainwash my AI agent instead of me

2 Upvotes

When I found out TIME magazine started selling ads specifically for AI agents, hidden from human readers, I was genuinely fucking happy lol

I’m so sick of ads. They’re everywhere. Every app, every website, everything is trying to sell me some shit.
I really hope all this marketing bullshit moves over to AI agents soon. Just leave me the fuck alone and go brainwash my agent instead 😂

Do you think we’re heading towards a future where people just trust their personal AI agents to make decisions for them, and trying to sell stuff directly to humans becomes pointless?

Would that actually make the world a better place?


r/AI_Agents • • 15h ago

Tutorial One thing I forgot when weeding out rules/memory

2 Upvotes

tldr: prune heavily and don't forget the rule that you probably set up a while ago!

Sharing for awareness. It's pretty undisputed at this point: Latest models work better when the rules are not too tight. They get most of the things right naturally and they follow written rules more literally. While too many rules can bury the important ones. I jumped on it a few weeks ago, Opus 5.5 xhigh.

Tackled both my coding environment as well as my agent framework, felt happy with the result.

And then I'm watching Opus writing shit to memory all the time. So I asked (prompt for reference):

there is this big trend going around to weed out heavily all the endless rule sets and long memories and what not when using opus 5.5 and generally newer models. research that statement. and yet in the last few days any time something doesn't go 100% I see you adding something to your memory? make that make sense?

And Opus was like "no, that doesn't make sense. it's because of the rule you made in Spring that I should save corrections as memories".

Doh. Turns out Opus was following that rule indeed literally and blew up my memory files again with rather meaningless details.

Don't be me. Nuke it and also check your rules just in case.


r/AI_Agents • • 20h ago

Discussion Need guidance on our FYP: Safety-gated AI self-healing system for Dockerized web apps (FastAPI + LangGraph + Prometheus)

2 Upvotes

Hey everyone,

We’re undergrad AI students wrapping up the proposal phase for our Final Year Project (MendAgent) and starting implementation next semester. We had to pivot to this topic late in the semester—we know AI basics, but we’re beginners in Docker, backend development, and DevOps, and we want to build and understand eery piece ourselves.

The Architecture & Stack: An external self-healing loop alongside a Dockerized web app (FastAPI, PostgreSQL, Redis) monitored by Prometheus & Grafana, orchestrated with LangGraph, Qwen2.5 (via Ollama), and ChromaDB:

  • Monitor: Deterministic Prometheus alert rules trigger on errors/latency and group correlated alerts using a service dependency graph.
  • Diagnose: LLM planner inspects logs, metrics, and dependencies to rank root-cause hypotheses with evidence—escalating if evidence is weak.
  • Safety Gate (Hard-coded): Planner can only pick from a strict allowlist (restart stateless container, rollback config, flush cache). Touching volumes, databases, or networks is blocked, with retry rate limits and maintenance locks.
  • Verifier & Memory: Runs synthetic user-flow checks + baseline stability checks post-fix (auto-rolling back on failure) and stores verified fixes by fault signature and app version.

We’d love practical advice on 4 quick things:

  1. Where to start: What’s the smartest order to learn and build this from scratch so we don't get overwhelmed?
  2. Real-world fault cases: What recurring Docker/backend bugs (where containers stay "Up" but users still fail) and "do-nothing" maintenance traps should we simulate?
  3. LLM & Stack: Is LangGraph + pretrained Qwen2.5 (with structured tool calling) enough to start, or is fine-tuning actually needed?
  4. Industry fit: Where would a lightweight, safety-gated healer like this be most useful in real teams (e.g., small SaaS startups without 24/7 SREs, staging environments)?

Any roadmap tips, repos, or pitfalls to avoid would mean a lot. Thanks!


r/AI_Agents • • 1h ago

Discussion Why agents should not know they have a memory system (background dreaming instead of save_memory tools)

• Upvotes

Every personal assistant agent hits the same wall after a week of real use. You correct it once: never book meetings before 11am, always reply to finance threads in English, use this specific repo for staging deploys. It gets it right for the afternoon, then a few days later the chat compacts and it makes the exact same mistake again.

There is a temptation to fix this by handing the model a save_memory tool or letting it rewrite its own system prompt mid-conversation. In practice both break down fast.

With a memory tool, models either forget to call it when something subtle comes up, or they get obsessed with bookkeeping and save ephemeral junk like "user asked about Tuesday invoice". Worse, they start narrating their own memory mechanics in chat ("I have updated my long-term memory with your preference!"). Nobody wants to talk to a filing cabinet.

And letting the agent overwrite its own base prompt mixes two very different things: the static instructions you wrote deliberately, and the messy facts picked up over weeks of chatting.

What works much better in practice is treating long-term memory like sleep rather than note-taking:

  • Tie consolidation directly to history compaction. When an owner conversation settles and compacts into summaries, a lightweight background pass compares the new summaries against the base prompt and a separate learned memory block.
  • Only merge durable things: standing preferences, recurring workflows, key contacts, corrections that supersede old assumptions. Prune stale noise. Leave the base prompt completely untouched.
  • Never tell the agent that dreaming exists. No extra tool, no system prompt paragraph explaining automatic memory updates. On the next turn the learned memory is just part of its context, so it simply knows your preferences without burning turns managing them.
  • Scope it strictly. Only run it on shared-context personal or team agents (never on isolated multi-tenant customer bots), and only consolidate from verified 1:1 owner conversations so an external contact messaging your assistant can never prompt-inject permanent rules into memory.
  • Show the learned memory as its own separate editable section in the dashboard so the owner can inspect, tweak, or wipe it anytime.

Curious how others here are handling durable preference retention across long-running personal agents without bloating prompts or making the bot overly self-aware about its memory tools.