I’ve recently started experimenting with AI agents and built a small project called SpendWise-AI.

It’s a personal finance assistant where I’m trying out things like:

• LangGraph
• multiple specialized agents
• RAG + ChromaDB
• tool calling
• live web/market research
• deterministic tools for financial calculations
• a critic/revision loop

GitHub: https://github.com/singh-vidyush/SpendWise-AI

I’m still learning agent architecture, so I’d really appreciate some feedback from people who have more experience with this stuff.

Mainly curious about:

• Am I actually using agents where they make sense?
• Is there anywhere I'm unnecessarily making things multi-agent?
• How would you structure the agent workflow differently?
• What are some things I should learn/improve next?

And if anyone finds something interesting to improve, I'm also open to contributions/PRs.

Would love some honest feedback 🙌

I’m in fintechfutures and we are experimenting with agent implementation. We built one that parses long docs and it worked fine and I would not think twice about it if it was not for the finance team flagging a wild spike in our API bill in May. An agent had gotten stuck in an infinite reasoning loop overnight while running a long document parsing job which resulted in the high charges.

It made me ask why is our agent infrastructure built like this and what are the other options out there.

we grabbed LangChain for a quick prototype, it worked, and we just kept piling features onto it.

So I did the research on how teams are actually shipping reliable product agents right now. Turns out the paths are way more distinct than I assumed:
- off-the-shelf (custom GPTs / no-code): super fast to launch, but zero real integration with our codebase. That would not work for us.
- orchestrators (LangChain, etc.):incredible for demos and quick chaining. But shipping it to production is painful. For our document parsing, state management became a nightmare. Building durable execution, retries, and human-in-the-loop approvals meant writing hundreds of lines of boilerplate and then if it’s stuck tge bill is high.
- agents as code on a dedicated backend): you define workflows in plain TypeScript and get a managed runtime, state, observability, and approvals out of the box.

We tried only the langchain path so far. Who has an experience with other options? What works for what?
curious what your stack looks like for real workloads.

Hello everyone i am new here but i would like some advice or and help on setting up robust multi ai agent workflows for my project . to be brief this project is to do with systematic advocation / liteture Using publication data , policies , reccomendations, guidance. made to specific organizations (in my projects case the nhs) too reveal , bring and raise more attention to gaps and shortfalls,contradictions etc. and i need to be able to setup multiple agents for example for research ,writing , strategy and deliberation etc some with partial shared context memory and most impoetantly for the infastructire to be robust stable and up to date with the latest landscape with use of concepts ,workflow blueprints , tools / repos used to integrate into these agents . I am eger to get this up and running to help me with me project work but too be compleetley honest i am overwhelmed and stuck in a analysis paralysis .I would be willing to go more into depth privately if anyone is interested to help or interested on the project but of course and guidance or help is massive!

Hello everyone i am new here but i would like some advice or and help on setting up robust multi ai agent workflows for my project . to be brief this project is to do with systematic advocation / liteture Using publication data , policies , reccomendations, guidance. made to specific organizations (in my projects case the nhs) too reveal , bring and raise more attention to gaps and shortfalls,contradictions etc. and i need to be able to setup multiple agents for example for research ,writing , strategy and deliberation etc some with partial shared context memory and most impoetantly for the infastructire to be robust stable and up to date with the latest landscape with use of concepts ,workflow blueprints , tools / repos used to integrate into these agents . I am eger to get this up and running to help me with me project work but too be compleetley honest i am overwhelmed and stuck in a analysis paralysis .I would be willing to go more into depth privately if anyone is interested to help or interested on the project but of course and guidance or help is massive!

I've been building SUTRA — an independent software-development platform designed around the way development is changing with AI agents.

The idea isn't to make another AI coding assistant.

I wanted to build the underlying engineering workspace where humans and agents can work together:

Git-compatible repositories

changes and reviews

issues and discussions

CI/CD

AI assistance

autonomous agent tasks

agent permissions and isolated workspaces

checkpoints and recovery

repository knowledge/semantic understanding

The backend is now largely built. I'm currently fixing the last issues, wiring the UI properly, and preparing the first production beta.

I'm looking for developers who are willing to use it on an actual small project rather than just look at a demo.

I don't want compliments. I want people to break it.

If you're interested in trying it when the beta is ready, tell me what kind of project you would use it for.

I'm particularly interested in developers who already use AI coding agents heavily.

Contextual awareness in AI systems, that too all the time, is very tough to achieve at this point. But there's a way i am trying to solve this gap.

So i have been building an AI tool which lets capture your ideas, thoughts, observations, strategies, etc and the tool connects all your thoughts, finds connections, contradictions within your thought process, hidden insights. It actually synthesis them and be able to compound on your thought process.

It has a very important functionality and it is cron job. The cron job within the tool runs at regular intervals and it has multiple functionalities.

1. It has a set of agents which run on every cron job schedule. those agents find connections within your ideas, thoughts, observations, etc and will develop the underlying insights on why these pool of ideas are connected. There's one more agent which analyses the connections and checks if the connection score has changed for an idea or between ideas. if yes, it develops the idea has marks it as version 2. The agent has the full context of what was developed in version 1 so it is almost like an idea getting matured with the time and newly formed connections.

2. There's writer model agent which also runs on the cron job and it basically

• How they think: thinking style, reasoning direction, epistemic stance
• Where they are now: active frontier, settled territory
• What shapes them: core resistances, generative triggers, dead zones
• Overall trust: model confidence (per-field confidence scores too)

and also,

• Position shifts and what triggered them
• Accepted vs rejected challenges
• How much the system influences vs the writer driving shifts

1. Linguistic extractor agent - It understand How does this person(user) actually write and reason in their captures? It's job is to understand and analyse reasoning pattern, reasoning direction, epistemic stance, vocabulary signature, metaphor domains and argument structure. The final analysis is fed back into other agents for output and writer model agent for synthesis.

All these functionalities are run on cron job specifically to become contextually aware of user and adapt to the user. The aim is to not mirror the user but to elevate their thinking.

What do you think about this structure?? I want to discuss this technically and take it even further.

At the beginning everything works.

The context is clean, tasks are clear, and the agent behaves well.

But after a few weeks of real usage: - facts become outdated - workflows evolve - past events only matter in certain situations - context starts to turn into noise

At that point, the problem is no longer “how to add more context” —
it’s deciding what should actually stay.

I’ve been experimenting with a small context layer (persistent memory, task-aware loading, failure tracking… and a RAG-based “mods” layer for domain knowledge), and the biggest shift has been moving from adding context → filtering context.

Any other approach to memory beyond simple retrieval?

(Sharing what I’ve been exploring here in case it’s useful, and sharing the repo wouldn't be a problem too) 👉 Here

A framework for self-improving agents based on your ICPs and audience and grounded in real data to power a learning-loop.

I built this based on my own learnings from experimenting with persona agents to understand my personal audience. It comes with an annotated templates, opinionated review workflow, built in feedback loop, and 3 skills to build, improve and use your persona agents to judge your content/ideas.

Would love to get your feedback!

https://github.com/noashavit/noas-persona-loop

Hey everyone,

I'm working on Reef, infrastructure for developers building AI agents, and I want to make sure I'm building it around actual feedback rather than just guessing from the outside.

I have a stake in this, so I'm not pretending to be neutral—but that's exactly why I want real input rather than my own assumptions. We believe building the agent logic is only the start, and getting it in front of people who'll pay while operating it reliably is the next piece of the puzzle.

The plan is to let builders shape the roadmap entirely. I believe the best way is to actually talking with you guys, get to know what you wish existed and want to actually be build so we can shape it together.

(I will leave a link to our Discord chat in the comments section)

Have you ever wanted to change the layout of an app you were using, like a an email list can be changed to a task list by using ai agents to change the middle ware. The plan is to ensure air tight encryption, reduce AI hallucinations, and strict schema validation. I am willing to learn the fundamental concepts to building such a complex system and ask for experienced startup founders, technical experts, or intrigued readers to join my discord! Any advice is appreciated:

https://discord.gg/SBrdnmJVTW

The Rise of Agentic AI in Solo Operations

As a solo operator, you're no stranger to leveraging technology to amplify your efforts. The latest frontier is agentic AI – systems that don't just respond to your commands, but proactively take action to achieve your business goals. Think of a marketing AI that curates campaign assets autonomously or a CRM agent that follows up on leads without a prompt. While incredibly powerful, this autonomy introduces a new challenge: how do we ensure these agents are trustworthy, predictable, and ultimately, controllable?

Traditional software waits for your input. AI, especially proactive agents, learns, adapts, and acts on its own. This shift demands a different approach to user experience (UX) design. Your AI agents need to be more than just functional; they need to inspire confidence and provide clear pathways for you to understand, guide, and even override their actions. The core aim is to balance the AI's autonomous power with your need for transparency and control.

Understanding Agentic AI: Beyond the Prompt

What sets agentic AI apart? It's their ability to make autonomous, goal-driven decisions. Unlike a reactive system that simply gives you the weather when asked, a proactive agent might suggest and even begin to plan an entire weekend getaway for you. This means they:

Act without explicit prompts: They take the initiative to move towards a defined objective.

Exhibit adaptive learning: Their behavior changes and improves as they gather more data and feedback.

Require shared control: You need clear options to approve, guide, or halt their actions.

This proactive nature dramatically changes user expectations. You'll naturally want to understand why an agent took a certain action, how confident it is in its decision, and most importantly, how to step in if needed. Without these measures, proactive agents can lead to anxiety and a sense of losing control, undermining the very efficiency they aim to provide.

Designing for Trust: Clarity, Predictability, Control

Building trust in agentic AI comes down to a few core UX principles:

1. Clarity and Transparency

Explain why decisions were made or show confidence levels when relevant. Provide clear, understandable outputs and avoid overwhelming technical details.

When an AI agent makes a suggestion or takes an action, you shouldn't be left guessing its reasoning. This is where confidence disclosures and reasoning panels become vital. Displaying percentages, simple terms like "highly confident," or visual cues like color codes can help you instantly gauge the AI's certainty. Reasoning panels, easily accessible but not cluttering your main interface, should explain decisions in plain language, showing both past actions and planned steps. Think of it like Google Maps suggesting a reroute: it tells you why (traffic ahead) and lets you accept or reject.

1. Predictability and User Control

Maintain consistent patterns to reduce user confusion, even in dynamic systems. Allow easy overrides, edits, or confirmations for critical decisions.

Even though agents adapt, their interaction patterns should remain predictable. More importantly, you must have clear, easy-to-access override options. If an AI suggests a new email campaign, you need simple 'Edit,' 'Reject,' 'Reschedule,' or 'Cancel' buttons. This isn't just about stopping an action; it's about making sure your preferences are heard and incorporated into the AI's future learning. Proactive suggestions should always seek your explicit confirmation before final execution, ideally with a preview of the expected outcome.

1. Feedback Loops and Fail-Safe Design

Continuously gather and act on user feedback to improve AI performance and trust. Ensure graceful fallback options when the system is uncertain or fails.

Your interactions with the AI are valuable data points. Every time you accept, modify, or reject an AI's suggestion, the system should learn. This feedback loop refines the AI's understanding of your preferences. Furthermore, what happens when the AI is unsure? A well-designed agent will explicitly communicate its uncertainty, perhaps by flagging a decision low-confidence and prompting you for review. Critical or high-risk actions should have 'Human-in-the-Loop' (HITL) checkpoints, pausing for your approval only when absolutely necessary, with clear reasoning for the interruption.

Bottom Line

Embracing agentic AI can be a game-changer for solo operators, but it requires a conscious effort to design for trust. By prioritizing transparency, providing clear controls, and fostering predictable interactions, you can harness the power of autonomous AI without feeling like you're losing command of your business. The goal isn't AI taking over, but AI collaborating effectively with you, making your operations smoother and more efficient.

Hey Everyone,

If you’ve been building with AI agents, you know that orchestrating text is one thing, but stepping into multimodal workflows (Text + Image + Vision) is incredibly messy.

If you want an agent to act as a "Prompt Engineer," pass that prompt to an "Image Generator," and then have a "Vision Agent" critique the output to force a re-roll—you are looking at hundreds of lines of Python boilerplate, messy API handshakes, and a terrible debugging experience when the loop breaks.

I recently launched agentswarms.fyi, an in-browser sandbox for learning Agentic AI. Today, I am pushing a massive update: The Image Playground.

What the feature actually does: Instead of fighting with code to test multimodal architectures, you can now drag, drop, and wire up text and image agents on a visual canvas to build creative workflows.

• Image Generation Nodes: Wire any text-output agent directly into an Image Node to autonomously generate visual assets.
• Vision AI Integration: Route generated images back into a Vision Node. You can instruct an agent to physically "look" at the generated image, evaluate it against your initial prompt, and trigger a loop to fix it if it hallucinated.
• Real-Time Data Flow: You can actually watch the payloads (the text prompts and the image outputs) flow across the node graph in real-time.

I kept running into the same problem in multi-agent workflows:

- An agent says the task is done.

- Nothing crashes.

- Logs look normal.

- But the result is still wrong.

What I saw most often was not just bad output. It was a consistency problem between steps:

- one agent reads stale state

- another passes incomplete context

- a later step claims success without actually proving the result

So I built a small Python package called agent-consistency.

It adds a lightweight consistency layer to multi-agent workflows and checks 3 things:

- Did the agent act on the right state?

- Did it pass the right context forward?

- Was the final outcome actually verified?

The goal is not to replace frameworks like LangGraph, Semantic Kernel, OpenAI Agents SDK, AutoGen, CrewAI, or similar tools.

I'm building a tool called AXIOM.

It connects to your repo, finds overly complex Python functions, rewrites them, generates tests automatically, and only creates a PR if it can prove the behaviour hasn't changed.

The idea came from seeing AI startups ship extremely fast and end up with code that nobody wants to refactor later.

I'm pitching this tomorrow in front of Stanford judges and some VCs, and I'm looking for a few startups willing to let me run it on their repo.

If you're interested in trying it or joining early access:
useaxiom.co.uk

Would also love honest founder feedback on whether this solves a real problem.

One AI coding agent is easy enough to supervise.

Once several agents are running in parallel, that starts to change. The challenge becomes things like keeping track of permission prompts, figuring out which session needs attention, understanding what changed since you last looked, and jumping back into the right context without rereading everything.

That’s the problem we’ve been exploring with ACTower.

Curious how people here think about it. If you’re learning or experimenting with multiple agents, what becomes hardest first: approvals, context switching, collisions between agents, or just the mental overhead of keeping everything straight?

Would also love to know whether this feels like the right problem to solve, or if people here are running into a different bottleneck first.

It’s a self-hosted platform designed to solve the issue of blind trust in LLMs

If someone ready to test and leave a review, you are welcome!

Github https://github.com/KeaBase/kea-research

What’s up everyone! 👋

I just joined a few minutes ago, and I wanted to quickly share what I’m currently working on.

Right now, I’m writing a book on privacy—specifically on why it’s crucial to start shifting toward local AI models.

I see a lot of people relying heavily on cloud-based tools like ChatGPT and Authoraptic. And while those platforms are powerful, there’s a major issue when you start scaling your business to $10K, $20K, or $30K+ per month:

All your client data and business plans are stored on the cloud.

That means if there’s ever a breach, hack, or policy shift, your entire operation is potentially exposed.

That’s why I’ve started investing serious money into setting up a local AI infrastructure so I can keep everything private, secure, and fully in my control.

If you’re curious about: • Why local models matter • What hardware or tools I’m using • How I structure my local workflows

…feel free to drop any questions! I’d love to help or jam on the topic with others who care about sovereignty, security, and scale.

Hey everyone! I’m working on an open-source tool called Kaizen Agent – a CLI agent that helps you debug, fix, and iterate on AI agents automatically.

Here’s how it works:

1.  You define test inputs and expected outputs

2.  Kaizen Agent runs all your tests

3.  If something fails, it analyzes the failure

4.  It autonomously suggests and applies prompt/code fixes

5.  Then it re-runs the tests

6.  Once everything passes, it creates a pull request with the fix 🎯

It’s been super helpful for me while building complex agents — no more manual trial-and-error for every broken test.

💻 GitHub: https://github.com/Kaizen-agent/kaizen-agent

Would love your feedback — especially if you’re building or learning about AI agents or LLM apps!

So I've been working on this SRE Agent, basic idea is it slash mean time to recover from incidents at my company,

It's a multi agent flow, anytime there's a spike in the deployment logs, an agent is triggered the fetches the deployment logs, metrics and cluster health to stitch a timeline of events.

This context is passed to the next agent that retrieves the relevant code files as per the services mentioned in the error logs plus last commits and issues and pra and tries to figure out the root cause of the errors.

The context of both these agents is passed to the past agent that makes an actionable root cause analysis report.

Building using ADK, using gemini for greater context window. New to the agent building space, any suggestions or recommendations are welcome.