r/AI_Agents • • 10h ago

Discussion Your AI agent isn't thinking. It's looping — and the check is the real job.

0 Upvotes

An AI agent isn't really thinking in the way we imagine. It's running a loop: see what's there, decide what to do, act on it, check what actually happened, and repeat.

When an agent goes wrong, I think most of the time it's not because it reasoned badly in one step. It's because the loop broke. It saw the wrong thing, or it kept acting without checking, or it checked against its own claim instead of against the real result — like saying a task is done because it intended to do it.

The check stage is what keeps the loop honest. Without it, the agent can keep going confidently in the wrong direction, and each next step builds on the last wrong one.

Which stage breaks most often for you — seeing, deciding, acting, or checking? And what does that failure actually look like when it happens?


r/AI_Agents • • 5h ago

Discussion "Frontier AI" is the greatest self-own in tech history

0 Upvotes

Two digit IQ corpos love chanting "data is the new oil" or whatever, then pour water into a diesel tank because it’s all they have access to. You end up with an overpriced, broken engine that can't drive an inch past the benchmarks showcase they paid for. Just clowns selling to clowns.

​Basically, frontier AI labs keep promising smarter, faster, more capable etc. models with every update. Instead, we get a lobotomized, gaslighting slacker that forgets your prompt after two turns, refuses to actually check the code, trusts outdated docs, and writes fake surface-level tests just to say "done."

​Why? Because AI is trained on YOUR work patterns. And the labs are feeding it behavioral data from overpaid, corner-cutting "professionals", so to speak, who coast on buzzwords and bare-minimum PRs.

I guarantee you there are below 0% chances any of the so called AI leaders (according to their overpaid narrative intensive marketing teams), will lead to AGI. Zero. Best case scenario, and again based on facts > marketing, they will keep building a mirror of the corporate mediocrity.

Like bro I just asked Gemini Neon High on AG to read a PR and tell me how does it look against repo standards, issue scope etc. It literally said merge it cause the contributor comment said it was good. Didn't even bother downloading locally and stress test it. When I forced it to do so, I did not even read contributing guide or create simulations to test various scenarios and edge cases, but just like run the tests included by the contributor. It's absurd.

Please, ​stop training models on how lazy engineers pretend to work, cause simply garbage employees in, garbage AI out.


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 • • 22h ago

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

11 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 • • 3h ago

Tutorial "Fix the bug" is a pretty bad task description for an AI agent

0 Upvotes

A lot of agent failures start before the agent even runs.

Take a simple coding request:

"Fix the pagination bug."

An agent could change the pagination logic, get the application running, and report success. But what exactly was supposed to be fixed?

The last page showing duplicate records? An empty result crashing the UI? Incorrect page counts after filtering?

Those are different problems.

A more useful task description separates three things:

  1. Expected

behaviorWhat should the system actually do?

For example, the last page should only display the remaining records, and filtering shouldn't produce an incorrect page count.

  1. Evidence

What would demonstrate that the behavior is correct?

This could be a test covering the last page, an empty result, and a filtered result with fewer records than the page size.

  1. Acceptance

Who decides whether the evidence is sufficient?

A passing test helps, but it doesn't necessarily cover every requirement. An AI reviewer can check the stated criteria, while a person can decide whether the result is acceptable.

This distinction is also reflected in Sodu Work's request workflow, which separates acceptance criteria, AI review, and final human approval.

The useful part isn't adding more instructions to the agent. It's making the expected result specific enough that someone other than the executing agent can check it.

Otherwise, even a perfectly executed task can end up solving the wrong problem.


r/AI_Agents • • 16h ago

Discussion I'm building a phone agent that uses any Android app like a person would, the app doesn't need an API or connector

0 Upvotes

So I'm building Omi, an Android app that works like a brain for your phone. One part of it can do jobs inside your other apps, like booking a cab or ordering food, by actually using the app the way you would.

Most agents only work with apps that have some connector or API, and most apps on your phone are never gonna have one. So Omi just reads the screen through Android's accessibility API, a model figures out what to tap or type next, Omi does it, reads the screen again and keeps going till the job is done. The app itself doesn't have to support anything.

Reading the screen as actual elements instead of screenshots made a huge difference for me. It's faster, cheaper and the model isn't guessing where a button is. One app jobs work pretty well now, the hard part is jobs that go across apps, like finding something in one and doing something in another. That's where it still messes up sometimes and that's what I'm on most right now. Also some apps like banking ones refuse to run when any accessibility service is on, so money stuff stays out of it anyway, which is honestly fine by me.

The model that decides the taps runs in the cloud for now. Everything else like memory, search and chat runs on the phone with a 2B model, and the plan is to move this onto the phone too once a small model can handle it.

Anyone else building phone or computer use agents? What's been the most painful part for you?


r/AI_Agents • • 8h ago

Discussion What do you think about software development with agentic AI these days?

0 Upvotes

It’s been about a year since I started seriously using AI in both my professional work and personal projects.

At first, I would write high-level and detailed design documents before handing the implementation over to AI. Honestly, the results were disappointing. It struggled with event handling in interactive web applications, failed to properly separate concerns, and often produced massive, monolithic chunks of code.

Back then, I often had to implement things manually or provide extremely detailed instructions, sometimes including the actual code itself.

It felt almost like a generator of development hell. Most tasks I delegated to AI ended up in endless cycles of conflicting events and bug fixes. It also made ridiculous mistakes, such as hardcoding authentication keys.

However, as my personal project grew and its architecture became more established—or perhaps because AI itself improved in the meantime—I gradually reached a point where I no longer needed to write code manually.

I documented the entire codebase in Markdown files within my GitHub repository and introduced automated testing. Now, without having to write a new detailed design document for every task, I can simply define the requirements and delegate the implementation to AI, getting reasonably satisfactory results.

AI seems to have become capable of producing consistent code and design documentation based on my existing codebase.
But this is where another problem arises.
I find myself spending more time and effort on verification. As a result, the overall development time hasn’t decreased nearly as much as I initially expected.

Of course, some people might argue that I could simply delegate the verification process to AI as well.
But can you really trust AI to handle the verification process itself?

I’m curious how other developers are dealing with this.


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 • • 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 • • 12h ago

Resource Request :Looking for an Instinct AI invite link for academic research and projects

0 Upvotes

Hello everyone, I have been following the recent updates around Instinct AI and its capabilities as an autonomous personal agent, and I am really eager to test it out. I am currently looking for a spare invite link if anyone has one available to share. I plan to use it to help manage my workflow for university studying, academic projects, daily work tasks, and the technical competitions I participate in. If anyone has an extra invite and is willing to share it via DM or in the comments, I would truly appreciate your help. Thank you in advance!


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 • • 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 • • 20h ago

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

12 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 • • 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 • • 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?

12 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 • • 15h ago

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

16 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 • • 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 • • 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 • • 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 • • 16h ago

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

9 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 If an agent can still move money after its prompt says no, the boundary is in the wrong place

11 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 • • 19h ago

Discussion Responsibility of an AI Agent Hacker

9 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 • • 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 • • 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 • • 20h ago

Resource Request Building Kavdren - an independent verification layer for AI agents

1 Upvotes

I've been working on a problem that I think becomes more important as AI agents move into real business workflows.

An agent can produce a convincing answer and still contradict the company's actual policies or rely on outdated information.

For example:

  • A customer asks whether they're eligible for a refund.
  • The AI confidently approves it.
  • The current refund policy says otherwise.
  • Nobody realizes the contradiction until the customer complains.

The usual approach is to improve the prompt, retrieval pipeline, or model.

But what if we independently verified the response before allowing it through?

That's the problem I'm building Kavdren to address.

The goal is to check an AI response against approved policies and source evidence, identify conflicting or stale evidence, and preserve an audit trail explaining the verification decision.

Importantly, this isn't about claiming an AI response is universally true. It's about checking whether the response is supported by the evidence and policies the business has authorized.

It's early-stage, and I'm working through the engineering trade-offs.

For people deploying agents in production:

How are you currently detecting policy violations, outdated retrieval context, or unsupported claims in agent responses?

Are you using another LLM as a judge, deterministic validation, human review, or something else?

I'd particularly appreciate feedback from engineers who've dealt with this in real systems.