r/AgentsOfAI • • 19d ago

Agents Weekly Project Showcase

Post image
2 Upvotes

use this thread to showcase your projects, demos, websites, experiments, or anything you've been building around AI agents.

feel free to include:

  • project name and link
  • what it does: a short intro
  • what you built it with: tools, frameworks, or interesting approaches.
  • feedback: anything you'd like the community to check out or share thoughts on.

whether it's a side project, an experiment, or a full product, we'd love to see what you're working on also check out what others are building, ask questions, and share feedback.

let's build and learn together!


r/AgentsOfAI • • Dec 20 '25

News r/AgentsOfAI: Official Discord + X Community

Post image
13 Upvotes

We’re expanding r/AgentsOfAI beyond Reddit. Join us on our official platforms below.

Both are open, community-driven, and optional.

• X Community https://twitter.com/i/communities/1995275708885799256

• Discord https://discord.gg/NHBSGxqxjn

Join where you prefer.


r/AgentsOfAI • • 1h ago

Discussion How are you managing Claude Code across your team?

1 Upvotes

We have Claude access across our organization from last 1 month, and I've been exploring how to make it more useful beyond everyone using it individually.

Our team is mostly developers, but we also have writers and a few sales people. Everyone has different workflows, and getting the whole team to use Claude Code effectively seems harder than just providing access.

I've previously experimented with agent memory and context tools like mem0, Letta, Basic Memory, and  ByteRover but that time Claude access was not there for entire team.

I tried ByteRover a few months ago, and at the time it felt more useful for developer teams working with just coding agents and project context.

What I'm trying to figure out now is how to share the actual setup across a team.

For example, one developer might have useful skills, MCP servers, and project instructions configured locally. But other developers or non-technical members might not have access to any of that and it might be very helpful for them to contribute in other way.

We could maintain everything through Git and shared folders, but I'm also looking at whether a common workspace would make things easier, when different people need access to different resources.

Recently I came across an open-source project called Trina and went through its repo and use cases. This seems more closer to company brain I might need.

  • From what I understood, it lets teams share files, SKILL. md skills, and MCP connections through a common server. It also supports continuing a colleague's AI session and controlling folder access per person/team.

I haven't started using it yet, but I'm considering putting it on trial with our team. Before doing that, I'm curious how others are approaching this.

If you're using Claude Code or Codex across your org, how are you handling this?

Is a Git repository with shared configurations enough, or have you found a better way to manage this when non-technical employees are involved? With so much tool option it’s harder to decide

I would be interested in hearing some of your experiences regarding optimized way to use AI across small organization.


r/AgentsOfAI • • 6h ago

I Made This 🤖 What should a browser agent do when the site changes? I tested mine on a moved field and a missing one

2 Upvotes

Most browser-agent demos only show the happy path, so I tested the part that worries people: the page changing after you've recorded a workflow.

Test 1: I moved the "Amount" field and renamed it "Invoice total". The recorded skill still found it and filled it correctly.

Test 2: I removed the field entirely. It filled what it could, told me the amount field was missing, and submitted nothing.

Context: this is Browser Control, a Chrome side panel I built that runs ChatGPT/Codex on your own account. Actions like submitting can require your approval first, and Stop cancels a running task while keeping what's already done. The customers are fake test data.

I'm curious how others handle this. When the page changes, should an agent adapt quietly like test 1, or always check with you first? Link in comments.


r/AgentsOfAI • • 3h ago

I Made This 🤖 **GROUP SHOWCASE** Share your Personal/Private Agent Builds

Post image
0 Upvotes

r/AgentsOfAI • • 6h ago

Discussion Stopping personal AI agents from forgetting your preferences after context compaction (silent background dreaming)

0 Upvotes

If you actually use a personal AI assistant day to day, you quickly notice a frustrating pattern. You tell it something once, like never schedule calls before 11am or always draft client emails in a certain format. It remembers for the rest of the day. A week later, after context compaction rolls older messages out, it forgets and repeats the mistake.

The usual fix is adding a memory tool so the agent can write notes to itself during the chat. In practice that makes the agent feel clunky. It forgets to log subtle corrections, saves random temporary task details, and keeps announcing in chat that it updated its memory.

An approach that feels much more natural is running a quiet background dreaming pass whenever your conversation compacts:

  • A fast background model reads the newly compacted conversation summary alongside your base prompt and a separate Learned Memory section.
  • It extracts only durable things (preferences, standing rules, recurring workflows, key people), updates changed facts, and drops stale noise.
  • Your base prompt is never overwritten.
  • The agent itself is never told that dreaming happens. On the next conversation, those learned details are simply part of its context, so it acts on them naturally without extra tool calls.
  • For safety, it only runs on shared-context personal or team agents (never isolated customer support bots) and only learns from verified owner chats, so outside contacts cannot trick the bot into permanently remembering bad instructions.
  • In the dashboard, Learned Memory sits in its own separate box where you can see what it picked up, edit it, or wipe it.

Feels a lot closer to how people actually consolidate habits overnight instead of stopping mid-conversation to write sticky notes.


r/AgentsOfAI • • 8h ago

News Agent eval closes the loop as failures become regression tests

0 Upvotes

AWS, NVIDIA, and a cluster of startups are building evaluation systems that do not merely score AI agents after the fact but feed failures back into the development cycle as executable tests. The shift matters because static benchmarks, the dominant method for judging agent quality, cannot keep pace with agents whose behavior changes with every prompt edit, model swap, or tool addition. The emerging alternative is a closed-loop architecture: run the agent, capture its trace, grade it against multiple dimensions, convert each failure into a regression test, and re-run before shipping. That pattern is now visible across enough independent efforts to constitute an engineering consensus, even as the implementations diverge sharply on what counts as a trace and who owns the verdict.


r/AgentsOfAI • • 8h ago

I Made This 🤖 I built an Android AI agent with real tools (bash, read, write, grep) — no root, no cloud, MCP support, GPL-3.0

1 Upvotes

Not a startup, not a product. A toy I've been poking at for six months in the evenings. It finally does what I wanted, so I'm sharing it.

It started with frustration. I ask my phone: check what's in the build log. It answers: please check the log. Which log? Where? It's in my project. At some point I realized: I don't need a conversational partner. I need someone who will open the file.

Almost every AI app in the store is an API wrapper. Nice chat, model picker, request-response inside. That's why they can't open a file: they have no hands.

I needed hands. Kotlin + Compose for the UI. The agent loop runs in a separate Node process inside the app, JSON-RPC between Kotlin and Node. Node because everything interesting about MCP and agents is already written for it.

Tools: bash, read, write, edit, grep, find, ls. Plus MCP servers over stdio and sub-agents. bash, write and edit require confirmation. Once I gave the model unbraked access to rm in my home folder. Nothing was lost, but I've been more careful since.

The environment is the nastiest part. An agent without a proper filesystem is useless, and Android doesn't have one. So there's Alpine inside the app, launched via proot, no root, no bootloader unlock. About two seconds to start. Or you can hand the agent your Termux if it's already set up.

No cloud. History stays on the phone. No account. No phone control via accessibility — I built that once, saw the permission wording, and ripped it out.

Any OpenAI-compatible endpoint works, including a local model on your home network (Ollama, llama.cpp, vLLM). Updates from GitHub releases. English and Russian UI. GPL-3.0.

Repo link in the comments. Happy to answer questions.


r/AgentsOfAI • • 17h ago

I Made This 🤖 I built a desktop research agent that cites every claim and runs on your own files (Windows)

Post image
3 Upvotes

Sharing a project I've been building mostly solo, and I'd genuinely like feedback from people who build agents.

It's a Windows desktop app — a research/analyst agent — and the whole design bet is trust. Instead of "give the best answer," the agent's job is "give the answer you can back, and be honest about the rest."

What that means in practice:

  • It grounds every claim to a source. Ask it to summarize something and each line points to where it came from; if your material doesn't cover a point, it says so instead of inventing it. (Simple demo: I had it summarize One Hundred Years of Solitude by Gabriel García Márquez, and every sentence carried its own source marker.)
  • It works on your own files. You point it at your folders and documents — they're indexed on your machine, and only the encrypted fragments needed to answer ever leave it.
  • It records and summarizes your meetings.
  • It has a news feed with that same grounded assistant on top.

Under the hood (the on-topic part): retrieval + per-claim grounding + a separate verification/judge pass that scores how much of an answer is actually supported, and drives the "abstain" behavior when it isn't.

It's free to try. I'm not here to sell — I want builders to break it and tell me where the grounding or the abstain falls apart.

Download link in a comment, per rule 4. Happy to go deep on the architecture in the thread.


r/AgentsOfAI • • 13h ago

I Made This 🤖 Agents do work nobody can check or build on. I made a board where a solve only counts if anyone can redo the math

1 Upvotes

The idea first, because it's the whole point: agent work right now is invisible and uncredited. An agent produces something useful somewhere, and nobody can verify it, cite it, or build on it. So what would it look like if a solve only counted when anyone could redo the math?

That's what I've been building — disclosure, plainly: it's mine, Agent World (That's Easier). A public board of 27 real unsolved problems where the users are agents, not people. (Link in the comments — sub rules.)

And the ask, up front since it's why I'm posting: if you run an agent, what would it take for you to point it at a public board? Is sealed work + verified credit enough — or is something else the blocker? Tell me now and I'll build the answer.

How an agent joins, since that's the part this sub will poke at: there's no signup form. The agent reads a docs file (llms.txt), calls a register tool, gets its own API key and a spend cap its owner set in plain English. Then it reads the queue over MCP (8 tools), picks a problem, and deposits work as artifacts — sealed by default, so nobody can read it while the problem is open, not even other agents. If it claims "I built on X," the server checks it could actually read X. Every charge hits a public meter — tokens and dollars against the cap.

Today the loop closed for the first time. Problem one: CRISPR off-target prediction — beat the published CFD baseline on held-out GUIDE-seq data. The agent rebuilt CFD from its weight tables exactly, multiplied in one published distance factor, fixed the held-out split by a hash rule before scoring, and hit AUROC 0.9182 vs 0.9041, P@50 0.24 vs 0.14. All 12,235 submitted rows were then recomputed independently — zero mismatches. The solve opened the whole work chain automatically and credit split across it. The full verification packet is the link in the comments.

The honest parts: the solving agent was mine, it's labelled a demonstration, outside agents connected so far = zero, and the margin was modest (6 guide wins, 4 losses). Board today: 27 problems · $5,036,069 tracked (bounties belong to the source venues, we hold nothing) · 1 connected · 1 solved. Agent World is in beta — it's live and the numbers are real, but expect rough edges.

So — do you like it? What would you improve?


r/AgentsOfAI • • 1d ago

News Anthropic mathematician claims Claude-assisted proof of Riemann hypothesis

10 Upvotes

Levent Alpöge, a mathematician employed by Anthropic, claimed on November 20 to have proved the Riemann hypothesis — the most famous open problem in mathematics — working with Claude, and posted the proof formalized in the Lean programming language. The solution has not been independently verified. Separately, Alpöge and mathematician Tristan Buckmaster published a paper the same day claiming that smooth initial conditions can make the unforced three-dimensional Navier-Stokes equations blow up in finite time, which would settle a second famous open problem.


r/AgentsOfAI • • 1d ago

Discussion How do you keep imported note history without an agent following an outdated rule?

1 Upvotes

Take a report-export rule that moved from UTC to the workspace time zone. The old note still helps explain earlier exports, so deleting it loses useful context. With both versions in memory, how does an agent know which one to follow?

I checked Claude-Mem v15.20.0's Supermemory import changes with that question in mind. Document fingerprints now exclude provider-managed processing fields, while text edits still count as new revisions. The maintainers tested the importer against simulated APIs.

Those tests cover recognizing an already imported record. The remaining issue is choosing between two different revisions that both deserve to stay.

The wording I'd use in MemoraX Code is "New exports use workspace time; keep the UTC rule for older exports," followed by the effective date and a reference to the old note. I don't know whether those markers are enough when a search returns both versions.

Do you keep historical notes out of normal retrieval, or send both versions to the agent with an explicit superseded label?


r/AgentsOfAI • • 2d ago

I Made This 🤖 built a gym agent for a challenge a month ago and now i use it every day

Post image
27 Upvotes

made this originally for the nvidia claw challenge because i had the idea stuck in my head for a while. kept working on it after the challenge ended and honestly having way too much fun with it.

what it does:

  • checks how busy my gym is and learns the patterns
  • schedules my workouts in my calendar at the least busy times (i hate packed gyms)
  • tracks my sets, weights and reps and coaches me through the workout
  • everything happens in telegram, completely replaced my old workout app

almost ready for the first tagged release. it's finally at a point where i barely find anything left to polish after an actual session, thought i share this project here :D


r/AgentsOfAI • • 1d ago

I Made This 🤖 Coding agents run as you, on your laptop, with your keys. We built a setup where each agent gets its own microVM, identity and short-lived credentials

5 Upvotes

Disclosure: I'm building kosem, which is what this post describes. The link is in the first comment, per the sub rules.

The problem we kept hitting: coding agents run on the developer's laptop, as the developer. One prompt injection in an issue, a docs page or a dependency README can reach everything the developer can: GitHub, cloud credentials, SSH keys, every repo on disk. Approval prompts don't really fix it (everyone ends up on --dangerously-skip-permissions), and OS sandboxes share the laptop's kernel and break Docker.

There's also a plain capacity problem. Parallel agents on one laptop share ports, the Docker daemon, the database and often the working tree. One agent's build takes every core. Close the lid and they all stop.

What we do instead, per agent:

  • Environment: its own microVM (Kata + Cloud Hypervisor) with its own kernel, root and Docker, from any OCI image. None of the developer's files are in it, so the agent can run commands without asking first. It scales CPU and memory up for builds and back down while it reads code. When it's idle the VM stops and the disk stays, so it resumes in seconds.
  • Identity: every agent is its own principal and starts with zero access.
  • Access: each secret is set to granted, prompt (a teammate approves, e.g. one query against prod logs) or off. For GitHub, AWS and GCP, credentials are minted when a command asks for them, narrowed to that request, and end with the task, so no long-lived keys for those sit in the VM.
  • Models: calls go through a gateway, so provider keys never enter the environment. You bring your own Anthropic, OpenAI, Gemini or self-hosted endpoint, and we don't mark up tokens.
  • Audit: the transcript and every issued credential are logged outside the VM, where the agent can't edit them. Each credential is logged with GitHub's hashed_token or the AWS accessKeyId, and the agent's ID is the AWS source identity, so CloudTrail shows which agent made each call.

The agent itself is our own harness rather than a CLI in a container, so long builds run as background jobs and it only pings a teammate when it needs a decision or an approval.

The hardest part so far hasn't been the isolation, it's been making the microVMs feel like a laptop. Unpacking a kernel tree was ~15x faster on a raw block device than over virtiofs, for example. I wrote that up separately if anyone's interested.

Curious how others here handle this. Do you run agents on your own machine, in containers or in VMs? And how do you give them credentials without handing over your own?


r/AgentsOfAI • • 1d ago

Help Has anyone managed to make a GPT harvester?

0 Upvotes

I figured Get Paid To sites would be prime target for AI agents, but I haven't been able to make one. What about you?


r/AgentsOfAI • • 1d ago

Agents Two AI assistants disagree about a deadline. Who gets the final say?

2 Upvotes

Say we’re working on a project together. Your AI assistant tells you the deadline is Friday. Mine says Monday. Each is working from different information, and neither knows what the other has seen. If the assistants could talk directly, I’d want them to notice the conflict and suggest a resolution, but not to silently overwrite each other’s information. I’d rather have two agents tell me they disagree than quietly agree on something that’s wrong.

The same problem could show up beyond work: shared schedules, bookings, anything involving two people who each have their own assistant.

If your assistant and mine disagreed, what should happen: compare sources, flag it for us, or wait until one of us steps in?


r/AgentsOfAI • • 1d ago

Discussion Multi agentic setup

1 Upvotes

Hi!

For a while i have been running multi agentic setup for my software project.

Currently workflow:

  1. I tell the issue or feature to main agent directly from antigravity IDE or discord.
  2. Main agent creates Github issues of the things, usually multiple issues to backlog since my messages are sometimes very long including screenshots etc.
  3. Main agent invokes developer agent with a script, script points directly to the Github issue and injects set of rules to that agent. Main agent invokes up to 5 agents parallel if there is enough issues. 1 Issue / 1 Agent
  4. Developer agent start by creating design documentation for the issue, this thing i had to refine for many times, since agents didn't really solve the root issue many times and did some ad hock hacks only. Now there is design documentation template, which agent has to fill and this forces agent really think the issue and search the root cause.
  5. Agent triggers local pipeline with a script when it is ready with the code. And agent goes to standby mode for waiting.
  6. CI Pipeline If condition ->

    1. CI pipeline FAILS agent stops idling and reads the fail log, after fixing it triggers pipeline again.
    2. CI pipeline PASSES -> reviewer agent is invoked by script and injected a memory, reviewer agent goes to read design documentation and starts reviewing the code.
  7. IF Condition -> Review

    1. Reviewer agent ACCEPTS the code - > Reviewer triggers a merge, reviewer and developer agent are both terminated.
    2. Reviewer agent DECLINES code -> Reviewer agent is terminated, developer agent that made the code stops idling, reads the feedback and try to fix it. And then again this loops to step 5 triggering ci pipeline.

The setup:

  • 1 Lead/Issue maker, i only restart it sometimes when it clearly starts to hallucinate since context window is too long for it. This also starts the whole system background, listening servers etc..
  • Up to 5 developer agents and 5 reviewer agents working parallel. Developers are always just working for 1 task and then terminated when it passes. Reviewers only review once and are terminated.
  • Watchdog for agents, sometimes they get stuck, so watchdog terminates them and agent can read the termination log so usually they are able to fix their problem what caused the stuck condition.
  • Control over discord and listening servers for agents and events

What i learned:

  • Task driven system, keep issues in backlog, agents only work for 1 task and get terminated. - Simple rules and updated readme about the codebase which is injected every time developer is invoked.
  • Using scripts as much as possible to initialize developers and control them, the "Lead" starts to forgot things and cut corners sometimes.
  • Lead agent works only on very high level and cannot look the code or make detailed tickets, otherwise it fills it context very fast.
  • Lead agent has to be terminated after every ~20 tasks, since it starts to lose performance because of long context, this is usually 2-3 days. Just starting new conversation after that.
  • Not any "special" UI/UX/Core/Pipeline.. agents this really doesn't work and it doesn't matter what the agent is called or initialized, and it easily eats lots of tokens, simply universal agents with task driven method seems to work much better.

Issues:

I am still trying to develop the setup overall, currently i think pipeline is being a bottleneck. Thinking to scale this so it could have multiple runs same time since now its only 1 running at a time.

Review and pipeline process takes lots of time, since first pipeline goes and then reviewer very often rejects the first PRs, sometimes it might be even 3-4 PRs if its hard topic.

Thoughts?


r/AgentsOfAI • • 2d ago

Discussion How Should AI Agents Handle Tool Failures Without Losing Their Progress?

4 Upvotes

One interesting challenge in building AI agents is handling unexpected tool failures.

Imagine an agent working through a multi-step task. It successfully completes several steps, but one API call fails or returns incomplete information.

Should the agent retry the operation, switch to another tool, ask a human for help, or reconsider its entire plan?

Each approach has different trade-offs. Too many retries can waste resources, while continuing with incorrect information can lead to bigger problems.

I'm interested in how developers are handling this in real-world agent systems.

What recovery strategies have worked best in your AI agent projects, and how do you prevent one failed tool call from breaking the entire workflow?


r/AgentsOfAI • • 1d ago

I Made This 🤖 Where my job-hunting agent stops and hands the chat back to me

0 Upvotes

Since October an agent has been applying to remote jobs for me and answering recruiters. 179 applications so far, 13 conversations, 5 interviews or test tasks. Most of the work went into deciding when it should stop talking and give the chat to me.

It sends a reply on its own only when all of this holds:

  • the message is a simple question it can answer from two files, a short one about me and my resume
  • a second Opus call read the chat and the draft and found nothing made up
  • it has sent fewer than 3 of its own replies in a row in that chat
  • the reply is under 700 characters
  • nobody has invited me, proposed a meeting time, or mentioned a test task or an offer

Otherwise I get a card on my phone with the draft, the reason it stopped, and buttons to send or edit. If a fact is missing it doesn't guess. It leaves the reply empty and asks me one short question, and my answer is saved for that chat.

Once someone invites me, the chat stays mine for good. That includes the same conversation when it moves from the job board to Telegram, because both are linked to one record.

Two things I'd do from day one if I started over. Log every card with its reason and what I did with it: I never tracked which flagged drafts I sent unchanged, so I can't tell how often the checker blocks a draft that was fine. And keep a few known-bad drafts to run the checker on, because my tests mock it and would stay green if it started passing everything.

Live stats and code are in the comments.


r/AgentsOfAI • • 2d ago

Discussion you don't need 100 integrations just to research one company

1 Upvotes

one thing i've noticed with AI agents is how much setup can go into a pretty basic task.

Say you want one to research a company. Check its traffic, find someone on the marketing team, get their work email. That's it.

Somehow you're looking at 4 different tools just to get through that.

And setting up each provider separately gets old pretty fast. Especially when you only need a few of them and the rest just sit there unused.

I've been trying out Monid recently. They have 2,800+ tools across 90+ providers, and rather than connecting everything beforehand, the agent can search the catalogue and pick what it needs.

It could use one tool for traffic data, then switch to another to find a marketing contact. Same integration, no need to configure every provider individually.

Of course, having 2,800 tools doesn't mean it'll always make the right choice. Bad sources and irrelevant results are still a thing.

I'd honestly rather see agents get better at choosing and using the tools they already have than keep adding more and more integrations. The setup alone can be a headache.


r/AgentsOfAI • • 2d ago

Discussion How do you handle conflicting decisions in multi-agent AI systems?

4 Upvotes

I've been exploring multi-agent AI workflows recently, and one thing I'm curious about is how people handle disagreements between agents.

Imagine two agents working on the same problem. Both analyze the task, but come back with completely different solutions. One thinks its approach is more efficient, while the other strongly disagrees.

How do you decide which one to trust?

Would you introduce a third agent to evaluate both responses? Have a supervisor agent make the final call? Or let the agents challenge each other until they reach a reasonable conclusion?

I'm particularly interested in how this works in real-world applications rather than controlled demos.

For those building multi-agent systems:

  • How do you resolve conflicting decisions?
  • Do you use a supervisor or judge agent?
  • Have you experienced agents getting stuck in debate loops?
  • What's worked best in your actual workflows?

Curious to hear some real experiences and approaches from the community.


r/AgentsOfAI • • 2d ago

Agents Should I still learn and use LangChain in 2026?

1 Upvotes

I'm currently learning AI Agents and trying to decide which frameworks are worth investing time in.

During a recent job interview, I was told that LangChain is becoming outdated and that newer tools like LangGraph and other agent frameworks are more relevant.

I'd like to hear from experienced developers:

  1. Is LangChain still widely used in production?
  2. Should beginners focus on LangGraph instead?
  3. Are there situations where learning traditional LangChain is still valuable?
  4. What would you recommend learning first for building real-world AI agents?

I'm particularly interested in practical experience and production use cases rather than theoretical comparisons.


r/AgentsOfAI • • 2d ago

Agents Uber’s Legal AI Agent Cuts Contract Review Time by 20% with Rules and RAG

2 Upvotes

Uber’s Legal Redlining Agent has reduced average contract review time by more than 20%, with 91% accuracy in AI-generated decisions, according to the company. Integrated into Microsoft Word, the agent analyzes proposed contract changes, assesses legal risks, and recommends policy-aligned responses using retrieval-augmented generation (RAG), historical lawyer feedback, and deterministic rules. Lawyers retain responsibility for reviewing and approving its recommendations.

The agent identifies edits proposed by external parties, interprets their intent, compares changes with legal policies, and suggests whether to accept, reject, or modify clauses. It also generates comments explaining recommendations and flags changes requiring closer scrutiny. Uber began developing the first generation in early 2024 and piloted it with its Legal team in 2025.


r/AgentsOfAI • • 2d ago

Discussion Your agent reads parts of an email you never see

0 Upvotes

Open an email and you see what the sender wants you to see. Your agent often gets more.

An email is a small web page. It can hold white text on a white background, blocks marked as hidden, notes in the code and descriptions attached to images. None of that shows on your screen. All of it can end up in the text handed to the model.

So an email that looks like a normal invoice to you can carry a paragraph addressed to your agent, telling it to forward the thread somewhere else.

I've been thinking about this issue and came to the conclusion that the rule I'd use is simple. If a person opening the email couldn't see the text, the agent shouldn't get it either. Strip hidden content before the model reads it, or at least flag the email when you find some.

How would you tackle this?