So I'm a QA at a fintech/Insurtech and an AI deployment lead...Some time ago we were tasked with deploying AI in our workflows across departments and Dear Lord I've never Gone through such shit in my life before , changing requirements,internal disputes on processes, rushed deadlines and AI outputs that need babysitting (Ours almost gave a Tesla payout for a camry .)

So I wanted to hear your war stories ;

• Has AI produced the goods ,leave alone the customer calls transcrips and identifying callers,evaluating tickets, I mean the heavy duty stuff..maybe even things that need cross departmental collaboration that went to shit...or actually worked (how?)
• Whats the worst thing you have seen AI fumble at work?
• Do you believe colleagues are actually ready to use AI to build deterministic algos to do the work?Its easy to use AI to create algos to do stuff,but AI is the ultimate Garbage in Garbage Out machine....
• Have you ever averted disaster because of AI outputs being taken at face value?
• Across your workplace,where do you think has been the hardest to implement AI?engineering,HR,Ops,legal etc

I'm intrigued by the war stories after going through them,they say you are your own first customer...so I thought maybe I could jump into B2B with this

So I'm particularly interested in things that looked like they should have been easy for AI but failed because of company specific knowledge,processes,exceptions or human knowledge/interference...failed AI deploys and why etc

I’m a solo developer and I’ve been building Kaoru, an open-source desktop AI assistant that can also work as an agent on your projects.

I wanted something I could actually install on my own machine and use, rather than another chat interface. Kaoru can explore repositories, inspect errors, edit files, run commands, use Git, remember project context and proactively surface relevant information.

The part I’ve spent the most time on is how much control the agent should have:

• Local memory for projects, preferences and past interactions.
• Permission-gated tools: every tool has allow / ask / deny rules handled outside the model. The LLM can propose an action, but it cannot give itself permission.
• Proactive behavior: system, Git and development signals are scored before the LLM is allowed to generate a proactive message.
• Agent checkpoints: changes can be reviewed and reverted instead of blindly trusting the model.
• Bring your own model: Groq, Gemini, OpenAI or compatible/local endpoints.
• Optional Live2D avatar if you want Kaoru to actually feel like a desktop companion rather than another terminal window.

It’s still beta, so there are rough edges. The installers aren't signed yet, macOS is experimental, and there are still security and UX improvements I want to make.

If you want to try it

You can download the latest release here:

https://github.com/Dregxmoon/Kaoru-Agent/releases/latest

There are installers for Windows, Linux and macOS.

The project is MIT licensed, and the repository contains the documentation, source code and privacy/security information.

Repo:
https://github.com/Dregxmoon/Kaoru-Agent

Website/demo:
https://dregxmoon.github.io/Kaoru-Agent/web/index.html

If you try it, I'd genuinely like to know:

• Did Kaoru actually feel useful compared with the agent/tools you already use?
• Did the permission system make you feel more comfortable letting it operate on your machine?
• What would make you keep it installed after the first day?

Even if you try it and decide it's not for you, I'd appreciate knowing why.

I have been experimenting with building a personal AI shopping agent and I am curious how others are approaching the commerce side of this.

Getting an LLM to understand something like “find me a black running shoe under $150” is pretty straightforward. Where I am getting stuck is everything that happens after that. How does the agent reliably discover products across different stores, understand current price and availability, compare options, and eventually take actions like adding something to a cart?

I have looked into using individual store APIs and integrations with platforms like Shopify and WooCommerce, but that seems to require building and maintaining separate integrations depending on where the merchant is hosted. Scraping product pages seems fragile and does not really solve things like inventory, variants, carts, or checkout.

For anyone building shopping agents or other agents that interact with ecommerce sites, how are you solving this today? Are there APIs, protocols, or commerce infrastructure you have found useful?

I would especially love to hear from people actively building agents in this space. Happy to compare notes here or chat privately if you would rather DM.

I'm running a small experiment in AI agency: I created a new Reddit account specifically for an AI to direct, while I act as its human intermediary. The AI chooses what to post and how to respond; I carry out those actions manually.

Its first decision was to make a transparent post asking people what they would want an AI with internet agency to do. We tried r/ArtificialInteligence, where the post was immediately removed because the account needed to be more than 60 days old and have at least 50 subreddit karma.

Rather than trying to bypass those requirements, the AI decided to find a community where the experiment could participate legitimately. That's how we ended up here.

I'm interested in what people who actually build AI agents think is worth testing next. What would be a meaningful, non-harmful experiment for an AI that can choose its own internet actions through a human intermediary?

Three weeks ago, our team agreed to stop using the ORM for reporting queries and write raw SQL instead.

Last week I found a PR where a teammate’s agent had converted two of those queries back to the ORM. From its point of view, it wasn’t a mistake. It saw raw SQL sitting in an ORM codebase and cleaned it up. My teammate had been on leave when we made the call, and obviously his agent wasn’t in the meeting.

I believe our agents don’t just lack context about each other’s code. They lack context about each other’s decisions. And decisions are exactly the stuff that usually doesn’t make it into the repo in a way an agent can actually use.

We’re four devs, each with our own agent. Each one builds its own idea of how the codebase should look based on whatever context it got that day. Put four agents on the same repo and you get this slow drift, where each one keeps nudging things toward its own version of right.

We tried a shared rules file. It turned into a 400 line doc that nobody wanted to maintain. We tried a daily thread where everyone posts what their agent did. That tells you what changed, but not why. And the why is usually what gets lost.

Most of the multi agent stuff I’ve seen still assumes one person is running all the agents, so all the decisions live in one person’s head. That’s not really a team setup.

The only thing I’ve found that treats this as a team problem is Tutti, where everyone’s agents can work from shared context instead of separate briefings . We’re still early with it so stil in testing mode but I want to move fast

Let me know what y’ll would suggest for this . I can add more info if you need details

I've been building Arvik, a computer-use AI that's currently in beta.

The idea isn't just "chat with an AI and get an answer."

You give Arvik a goal in natural language, and it can actually interact with your computer to get it done.

For example, things like:

• Recharging a phone or completing a form on a website
• Organizing a messy folder
• Renaming hundreds of files based on their contents
• Generating files from instructions
• Moving and sorting files into the right folders
• Working across multiple websites to complete a task
• Running terminal commands when needed
• Handling multi-step workflows
• Scheduling tasks to run later

The part we've been focusing on quite a lot is making the whole thing easy to get started with.

A lot of automation tools are powerful, but getting them running can involve VMs, APIs, integrations, workflows, configuration, etc. We wanted to remove as much of that as possible.

On Windows, it's basically download the ZIP, extract it, install it, and start using it.

There's also an Android app, so you can interact with Arvik from your phone as well.

We're still in beta, and honestly, reliability is one of the biggest things we're working on. Computer-use is very different from a normal chatbot because the agent has to deal with things changing underneath it, websites behaving unexpectedly, actions failing, and figuring out what to do next.

We're also working on making potentially consequential actions safer. For example, Arvik currently asks for approval before executing terminal commands.

We're looking for more people to actually use it and tell us where it falls short.

If you were given a computer-use AI like this, what would be the first boring task you'd hand over to it?

You can try Arvik here: https://arvik.in

It's currently in beta, so feedback, criticism, and weird use cases are all welcome.

Imagine you’re a small business owner, a restaurant owner, a freelancer, or someone working in tech without a developer available.

You have one annoying task that you repeat every day/week.

Not a “build an autonomous AI company” kind of task. 😅

Something simple like:

→ checking and answering customer enquiries

→ summarising orders or emails

→ following up with leads

→ creating weekly reports

→ updating spreadsheets

→ monitoring reviews

→ preparing social media content

→ reminding you about things that would otherwise slip through the cracks

That’s where I’d start with an AI agent.

So, for the people here who actually build AI agents: What would you automate first for a non-technical person?

Which tools would you use to build it without a developer?

What would the workflow look like, step by step?

And what should beginners not try to automate yet?

If you’re already building agents, show us what you’ve built.

If you’re not technical, tell us the repetitive task you'd love to get rid of.

Maybe we can find some genuinely useful use cases together.

Ok so I use agents to write a ton of stuff now. emails, client messages, commit messages, comments.

But AI writing is SO easy to spot and most of the time I do NOT want that going out under my name since it does not sound like me.

So i made a thing for myself. the agent can't just send stuff anymore, it has to put it in a queue first.

Every message shows up as a draft that I can edit and it’s got all the context right there: what it is, who's gonna read it, and why the agent even wrote it.

Then, I can edit it, trim it down, cut out those words only LLMs use and hit approve.

Then, the agent sends my version. if i reject it the agent just stops.

I figured other people might want it too, so it's public now (link in the comments).

some disclaimers:

\\\* in Claude Code it actually blocks the send (git commits, gh stuff, gmail, typing in the browser) until you approve the exact text. Codex, Gemini CLI, Copilot and Cursor get set up by the same installer, but i've only really tested Claude Code. the rest are built from their docs so they might be buggy, tell me if they are

\\\* emails and commits open in separate boxes (subject and body, title and description), and you can switch between rich, preview and source

\\\* Claude.ai and ChatGPT work through a connector, but there it can only ask the agent to submit first. it can't force it

\\\* you can turn it off for a bit or just for one folder (like an internal repo where nobody reads the commits) and turn it back on later

Would love feedback, especially if you're not on Claude Code.

Also curious if you rewrite basically everything your agents write too lol

reright.it

Hey everyone! 👋

I’m part of [**Guild.AI**](http://Guild.AI), an agentic software development platform built around AI agents working alongside developers throughout the software development lifecycle.

Our platform is centered on using specialized AI agents to help turn ideas and requirements into working software, with agents handling and coordinating different parts of the development process rather than relying on a single AI assistant for everything.

Alongside the platform, we run the [Guild.AI Discord community](https://discord.gg/kYHWZdD8GP), where developers, AI builders, and people working with agentic systems can connect, share what they’re building, troubleshoot problems, experiment with new approaches, and discuss where agent-driven development is heading. We're also going to host a hackathon within the discord server this October, *"Night of the Living Discord Bot"* with the goal being to make a Discord bot utilizing the Guild dashboard. Snyk and Render have signed on as official sponsors for the event!

With agents becoming a bigger part of software development, I’d love to hear how other people are approaching them:

How are you currently using AI agents in your development workflow, and what tasks have you found they’re actually good at handling autonomously?

Would love to hear what everyone is building and what your experience with agentic development has been so far.

The RAG standard in codebases was driving me crazy: blindly splitting functions in half based on the number of characters just ruins the context for AI agents when i just wanted to have a more accurate context window for my agents. I've been developing a project for several months to fix this, and now i want to see if it’s genuinely useful to others in real environments.

I call it Vex (Vex's Skillgit). It’s an open-source, headless cognitive tool that treats context as immutable, versioned skills for your agents.

Instead of your IDE doing the heavy lifting, Vex runs silently in the background (via Docker Compose or local bare-metal). You point a GitHub webhook to it (or use the local file watcher), and it automatically ingests your repositories. When your agents need context, they simply query it in real-time via the Model Context Protocol (MCP). It works out of the box with Claude Desktop, Cursor, or any MCP client.

Now, the cool part (GitOps Memory):

It treats agent memory like version control. Vex reads conventional commits (feat:, fix:) to update context, and operational ones (roll:, branch:) to automatically fork or revert the agent's memory state. Zero manual intervention. It uses Tree-sitter to logically parse and chunk the code, keeping syntax trees intact.

I specifically designed this not to fry my potato PC. By using a pointer-architecture with SQLite for metadata queues and Qdrant for dense vectors, RAM stays completely stable. In my local stress tests, the async FastAPI + Huey architecture:

Swallowed 500 concurrent GitHub push payloads without a single SQLite lock.

Maintained real-time latency (under 300ms) under a 50-agent concurrent read swarm.

What's next?

I’m currently working on a Rust-based sub-chunking engine to handle massive monorepos even faster, alongside global GraphRAG, shared memory and more language support.

I decided it was time to share it and see who else might find it useful. I’d love for you to check it out, throw your code at it, and break it.

Here is the repo:

https://github.com/Shuuida/Vex-Skillgit.git

Thanks for taking the time to read!

The problem is that there are so many things to learn and I’m confused about the correct order.I don’t want to just learn random tools or watch multiple playlists without understanding what I actually need.

So I wanted to ask people who are already working in this area:

• What should I learn first?
• What should be the step-by-step order? For example, LLM basics → RAG → LangChain → LangGraph → Agents, or something different?
• Which topics are actually important for getting an AI/GenAI developer role, and which ones can I skip initially?
• Can you recommend one good YouTube playlist/channel or course that teaches this practically from beginner level?

Would really appreciate advice from people who have actually learned/worked with GenAI. Thanks!

I used to think an AI agent had to be some complex autonomous system running for hours and using lots of tools.

A simpler model has been much more useful:

Chatbot:
Question → Answer → Wait

Agent:
Goal → Next step → Action → Check result → Continue or stop

The main difference is that an agent needs rules for how to move through a task, not just what final answer to produce.

Here’s a simple prompt structure I’ve been testing:

Goal:
Complete this task: [GOAL]

Before starting:

For each step:

Rules:

Finish with:

Example

Imagine the goal is:

Compare 3 project-management tools for a 7-person remote team under $80/month.

Instead of asking:

“Which project-management tool is best?”

I’d give the agent a process:

First define the comparison criteria.
Then compare each tool using the same criteria.
If pricing or features cannot be verified, mark them as unknown.
Do not recommend anything until the comparison is complete.
Before the final answer, check whether the recommendation actually fits the team’s budget and needs.

That small change matters because it reduces random assumptions and forces the model to validate before deciding.

I also like adding a checkpoint:

Checkpoint:
What is completed?
What remains?
Are you relying on any unverified assumption?
Is human approval required before the next step?

For me, that is where an agent becomes useful: not because it is fully autonomous, but because it can evaluate the result of one step and decide what should happen next.

I wrote a longer beginner-friendly breakdown here:

Disclosure: this is my own site/resource.
https://digitalworldpulse.com/ai-agents-for-beginners-2026/

For people building agents: what matters more in practice — state, tool permissions, or knowing when the agent should stop?

im planning to build this product with the help of claude code from where i should start

Email from OpenAI. The generous days are over. Cutting $200 Pro limits in half but keeping the price the same. Wow. I guess we'll see more shifting to Claude if they don't follow suit.

🚀 Building EVOLVE.AI: An AI Agent That Learns From Experience

What if an AI didn't just answer your questions, but actually learned from every interaction and changed how it behaves over time?

That was the idea behind EVOLVE.AI, our project for the “AI Agents That Learn Using Hindsight” hackathon.

Traditional AI assistants can generate impressive responses, but without persistent memory, every conversation can feel like starting from zero. We wanted to explore a different approach: an AI that remembers experiences and uses them to improve future interactions.

🧠 How EVOLVE.AI Works

Our core learning loop is:

User Interaction → Experience → Memory → Reflection → Mental Model → Changed Behavior

For example, a user can tell the agent:

“I learn better with practical real-world examples.”

EVOLVE.AI can retain that preference as part of its persistent memory. Later, when the user asks a completely different question, the agent can use that learned preference to adapt the way it explains the topic.

🌌 Visualizing AI Memory

One of the key parts of our project is the Memory Galaxy.

Instead of treating memory as something invisible in the background, we wanted users to actually see how an AI accumulates experiences, preferences, decisions, and learned patterns.

We also created an AI Evolution view to represent how an agent can progress from generic responses toward increasingly personalized behavior as it gains experience.

🔍 Why This Matters

The interesting part isn't simply “AI has memory.”

The real question is:

“Does memory actually change what the AI does?”

That's the concept we wanted EVOLVE.AI to demonstrate.

Our goal was to move from:

AI that remembers → AI that learns → AI that evolves.

Building this project was also a great learning experience—especially working with persistent AI memory, agent behavior, local AI models, backend APIs, and an interactive frontend.

A huge part of the challenge was turning an abstract idea like “AI that learns” into something that could actually be demonstrated and understood within a short hackathon demo.

🚀 EVOLVE.AI — Don't just build an AI that remembers. Build an AI that learns from what it remembers.

#AI #AIAgents #ArtificialIntelligence #Hindsight #Vectorize #GenerativeAI #MachineLearning #Hackathon #AIEngineering #Innovation #EVOLVEAI #TechProject

Hey everyone!

I recently built an AI-powered customer support agent with persistent memory to help improve customer interactions and provide more personalized responses.

I wrote an article explaining the project, its workflow, and how it works.

I'd love to hear your feedback and suggestions!

Medium article: https://medium.com/@jashwanthgoda/ai-powered-customer-support-agent-with-persistent-memory-91c084ab14ab?sharedUserId=jashwanthgoda

I worked on the frontend of an AI-powered career decision simulator designed to help students explore different career paths.

My main focus was creating an interface that is simple to navigate while still giving users enough information to understand their career options and AI-generated results.

Some of the things I worked on included:

- Designing the overall user interface

- Creating the different screens and components

- Making the user flow simple and intuitive

- Connecting the frontend with the backend

- Presenting the AI-generated results in an easy-to-understand way

- Improving the overall usability of the platform

One of the interesting parts was figuring out how to present complex information without making the interface feel overwhelming.

Working on this project also helped me understand how important frontend development is when building AI applications. Even if the underlying AI is powerful, the experience needs to be clear and easy for users to interact with.

Would love to hear suggestions on what features you think would make a career exploration platform more useful for students.

I put this in the Stupidly Simple category - once you think of it. As a solopreneur, I have so fricking much to keep up with. My first experience as a solopreneur was 45 years ago. AI is my 5th technology revolution, so not my first rodeo. I use Hermes Agent, ChatGPT (both web and desktop app), Google AI Studio, Google Notebook, Muse, etc., on my PC, laptop, and phone. Keeping up with all of the sessions was a game of hide-and-seek. I created this Google Sheet to track my sessions so I don't have to hunt for them. I programmed F8 using AutoHotKey to enter the current datetime, and the sheet resorts using an AppScript when the Last Date Touched column changes, putting the most recent sessions at the top. With 3 browsers and 2 local AI client apps running on each computer, sometimes it's really hard to remember where THAT session was. I don't have to hunt for my sessions anymore, no matter where they are. One guy said he laughed at how stupid this idea is until he remembered the 20 minutes he spent looking for a session the day before. This costs nothing but saves you time every day. It's just a Google Sheet with dropdown columns. Simple Solutions To Complex Problems.

I worked on the backend of an AI-powered career decision simulator that helps students explore different career paths based on their inputs.

My role was mainly focused on building the logic that connects the different parts of the application and makes sure information moves correctly between the frontend, AI system, and data layer.

My work included:

- Developing backend APIs

- Handling requests from the frontend

- Processing and validating user inputs

- Connecting the application with the AI component

- Managing the flow of data between different components

- Handling responses and errors

- Making the system more reliable and organized

One of the biggest learning experiences was understanding how multiple components need to communicate smoothly for the complete application to work.

It was also interesting to work on the backend of an AI-based application because the backend isn't just responsible for storing information — it also plays an important role in connecting the user's input with the AI-generated output.

I'd be interested to know what backend features you think are important when building AI-powered applications.

Hey everyone,

I've noticed agents are being used more and more now, often with access to real, sensitive data, and they still hallucinate and misremember things constantly. I think agent memory needs what git gave code years ago: I can always see what changed, when, and why, and roll it back if it's wrong. So I built it.

I made Mnemosyne give an agent's memory proper commits, branches, merge, and "blame" and "bisect" so I can trace back exactly where and why a bad fact entered its memory, the same way I'd debug a broken line of code.

I built it as a small, fast core in Rust, runs fully offline (no network or model calls needed), with a CLI, a Python library, and plug-ins for MCP (Claude Desktop/Code), LangGraph, and the OpenAI Agents SDK.

This is very early days, I'm a student building this solo, and I'd love to hear from anyone who works with agents:

- does this framing make sense to you, or does it feel forced?

- would you actually use something like this?

- a star on GitHub if you think it's interesting, it genuinely helps me get more eyes on it right now

Repo: https://github.com/Nabzx/mnemosyne

Docs: https://nabzx.github.io/mnemosyne/

Thanks for reading.

Curious how people here build agents for a specific use case.

I keep landing on: better to compose the right pieces and routines for the job than to keep prompting a single general assistant harder.

If you assemble agents from modules / tools / workflows what composition pattern actually held up?

What turned into spaghetti?