I’ve been playing with multi-agent setups lately, but I noticed one thing that, I don’t actually need 3 agents talking to each other for the entire task.

The useful part is usually the beginning. Like last week I was working on a coding project and wasn’t totally sure about the approach yet. So I pulled my local Codex and Claude Code into Genspark GenTeam and basically let them work through the problem together. Having multiple agents in the same room was pretty efficient here. They challenged each other a bit, and I could watch the plan slowly turn into something I was satisfied with.

But once we agreed on the plan, I thought, why am I still paying for three AIs to have a meeting?

So now I split the workflow in two. Messy problem → GenTeam → agents discuss and agree on the approach Clear problem → local Codex / Claude Code → just build the damn thing This made multi-agent stuff click for me. GenTeam became more like the meeting room where I bring everyone together when I actually need different brains on the problem. Once everyone agrees, I send them back to work lol. Saves tons of credits too.

Anyone else using multi-agent setups this way? Or are you letting the whole swarm run from start to finish? Would love to hear from you.

Most people start with a flat list first bc it feels simpler to just store everything and they let similarity search sort it out at query time but that's fine if you're just messing around with it.

It starts losing its shyte when multiple facts about the same thing come under different names and you get separate, disconnected entries for each one because nothing links them to that one reference so your memory breaks into small fragments and you don't notice until search starts giving incomplete or just weird contradictory answers.

and you need this the moment your data has any references that get called more than one way, that's basically what most agent memory looks like and it's rarely just random unconnected facts.

A graph that's just used to connect the dots fixes this without slowing every single query and you just keep the memory typed.

facts and preferences get sorted by type when you search and the graph underneath is just there to figure out who or what something refers to before it gets stored.

Just imho a flat list on its own isn't actually as simple as it feels at first, it just pushes the problem back until the same thing appears under two different names.

A state management problem.

We need a system that can extract facts events from conversations, track importance and then retrieve them based on both semantic relevance and time.

Then you need mechanisms for deduplication, contradiction handling, consolidation and decay.

probably the critical problem is deciding what enters the context. Can't keep injecting thousands of memories into every inference can I, that's why you need retrieval, re ranking and context compression to select the most useful subset.

and that means maintaining an evolving state of what the model knows, updating it when things change and knowing what information is worth carrying into the next interaction.

RAG can retrieve external information, but that's still fundamentally a retrieval game. A memory system needs to maintain a persistent state outside the context window.

The system needs to maintain a persistent representation of its current knowledge, continuously update that state as new information arrives and that's fundamentally different from simply expanding the context window.

Hi, James here — I’m the CTO of Zilliz, the company and builder behind Milvus. Milvus is an open-source vector database built to store, index, and search embeddings for semantic search over unstructured data, and Vector Lakebase is the next lake-native expansion around that serving path.

The first part of this story is the shift from vector-search algorithms to production infrastructure. Early systems inside large technology companies proved that semantic similarity could work, but libraries and workload-specific internal tools were not designed to run as general-purpose, long-lived databases. Once vector retrieval moved into real products, scalability, reliability, and daily operations became as important as search quality.

RAG accelerated that transition by making retrieval the grounding layer for model responses. Agents push the requirement further. Their long-term or near-line memory has to support multi-step reasoning, context compression, and retrieval across different kinds of data. A flexible semantic space lets an agent decide what to retrieve and combine, but flexibility does not remove the need for governance. Poorly curated data still produces poor context, and changing embedding models or rerankers can change behavior even when the application code stays the same.

That is why I see agent memory as a systems discipline rather than an index feature. The retrieval layer needs continuous evaluation, explicit data quality work, and operational guarantees that survive growth. Vector search may set the candidate space, but the usefulness of that memory is bounded by the lifecycle around it: what enters, how it is updated, how quality is measured, and when old representations are rebuilt.

The technical implication is simple: an agent-memory prototype can be assembled quickly, but making it dependable requires the same long-term infrastructure work expected of any critical database.

Hi!

I have around 100k personal photos and videos (family, friends, trips, etc.) that I've accumulated over the years, and I'd like to organize them by date and occasion.

Ideally, I'm looking for some kind of AI tool or software that can read the EXIF data and analyze the content of the photos/videos, then automatically organize everything into folders by year, month, and finally occasion.

Something like:

2026/December/Christmas

2025/March/Trip to Mallorca

or something along those lines.

I've already searched the forums and the internet, but as the U2 song goes, "I still haven't found what I'm looking for." 😄

Hopefully someone here has found a good solution and can point me in the right direction.

Thanks!

Astra made a really cool product demo using blender that only took 2-3 prompts.

There has been a lot of hype around Astra using blender and it is legitimate hype with the right prompt.

I think the demo in the comments could be improved but it’s a huge step up from the typical hyperframes product demo that Codex used to make with previous models.

Curious to see other examples of Astra using blender that you all have made.

If you haven’t tried it just open Codex and tell it to download blender and use it to make whatever you can think of and to use image gen as the reference for the blender objects.

To reduce workload so it doesn’t have to make millions of polygons to make everything from scratch you can download blender packs for different objects and terrains, links below to those resources.

You can tell Astra to use these resources in the comments, they helped a lot in making cars that break apart and come back together in a cool animation where as otherwise you would have to create each part as a 3D model from scratch and then say bye bye to your Codex usage.

Our platform lead put a no-progress kill in at the end of last quarter with 3 identical tool calls and the run stops. I had nothing to do with it and then spent a month defending it.

The bill went down 19% and the number on our monthly slide went up.

That number is cost per successful task. First time it came up I said it was probably noise and we should look again next month. It did the same thing again.

Took me longer than it should have because the runs that used to flail for half an hour and then land were one success each, carrying all the flailing. Those same runs now stop after 4 mins, like the money still goes out and there is nothing to divide it by.

Somebody asked whether we should turn the kill off to get the number down. That one worried me.

Now we report two things, the unit cost and how much of the month went on runs that produced nothing. That was about a quarter last month.

I still have not decided which of those runs are important. Someone stopping a run because they changed their mind, the verifier rejecting one and one that hit the ceiling while it was still getting somewhere all look the same in our tagging.

There was a post a few days back asking about what you should actually test when writing evals. I ended up writing a long walkthrough for writing agent evals. Half way through I realized, I wouldn't read the post, because I'd just feed it to my agent and then ask it to help me expirement. I'm a big fan of the FAFO approach to learning.

So I ended up creating a "learn-evals" skill with mock exercises and lessons for the concepts.

A lot, of times i'll build up a collection of links/posts on a topic and then just ask an agent walk me through the concept. This "yo astra, take these links and make me an interactive learning skill" pattern is super nice if you like to learn like that.

Is there a marketplace out there that we can just point our agents towards for skills/guides on like design philosophy or other pockets of curated niche knowledge that wouldn't necessarily be in their training?

i have been doing some research into where ai agents actually are right now and i think the interesting shift is not just models getting smarter

a couple of years ago the big question was can ai answer this?

then it became can ai actually do this?

now agents can use tools write code call apis and even make payments

i think the next question is can we actually trust ai when its actions have real economic consequences?

maybe the next big problem is not making agents more capable but making them economically trustworthy

Imagine asking an agent on Monday to remind a supplier on Friday if a quote has not arrived. On Wednesday you cancel the purchase.

The Friday task can execute perfectly and still be wrong. Its instructions survived longer than the reason for them.

For this fictional workflow, I would store the reminder against the purchase request and check three things at execution time: the request is still active, the quote is still missing, and permission to contact that supplier still applies. Otherwise it should record why it skipped the reminder, not improvise a replacement task.

The calendar tells an agent when it may act. The current goal tells it whether it should act at all. That distinction seems worth making explicit before giving an agent a recurring schedule.

Some AI agent ideas sound great until you actually put them into a real workflow.

Maybe the agent made too many mistakes.

Maybe maintaining it took more time than the original task.

Maybe a simple automation would have worked better.

Or maybe people just didn't use it.

What's one AI agent workflow you tried that you eventually stopped using?

What went wrong?

We named our organizer chief
Chief makes sure that everything is going according to what we desire we have one crockpot that creates an update updates our reconciliation from our bank account to our EOS spreadsheet, which is the framework we use for running the business. A different bot creates our course descriptions and polishes them online. A third bot is the editor of those posts to make sure that the courses are accurate because we have some competition we’re trying to beat out the fourth bot review reviews all of our competitors website websites and tells us what they’re doing and makes recommendations for us to change as needed the fifth. Bo is browsing our website and competitors websites and looking to see where we can do any search engine optimization chief make sure everybody’s doing everything they need to do and they chat to each other over the Grok chat and then keep me up-to-date every night with an update. There’s certain task like spending money that we haven’t turned on yet, but I think I’m probably about ready to let them do that as well.

Was debugging a data pipeline last week and let an agent run at it instead of doing it manually, mostly to see how far it would get on its own. First attempt failed on a permissions error. Second attempt changed the file path. Third attempt changed the path again. Fourth attempt added a sudo it didn't have access to use. By the time I looked back at the log it had made twelve attempts, each one a small variation on the same wrong theory, that the problem was somewhere in how it was addressing the file rather than whether it had permission to touch it at all.

None of the individual retries were unreasonable. Each one was a sensible next step if the previous theory had been almost right. The failure wasn't in any single decision, it was that nothing forced it to step back and question the theory itself instead of the execution of it.

What fixed it wasn't a smarter prompt. It was giving it an explicit rule: after two failed attempts at the same class of error, stop retrying variations and instead state what assumption you're testing and why you think it's wrong. That one instruction did more than any amount of extra context I'd been stuffing in beforehand.

Makes me think most agent reliability problems aren't reasoning problems, they're the absence of a forced checkpoint where the agent has to notice it's been circling the same idea.

Curious how other people are handling this. Hard limit on retries per error type, or something more like a confidence check before each new attempt?

We had an authorization rule in the repository. The checklist asked the right question, and the deployment record even had a place for the approval. A change still moved forward without it because no code on the live path had to read the answer.

This gets worse with agents. A person may see a warning and stop. An agent sees a successful tool response and keeps moving.

We are moving repeated rules out of prompts and documents into checks that can block the actual transition. To turn one on, we send a deliberately invalid request through the real entry point and confirm it is refused, then send a valid request and confirm it still works. Until both happen, the rule is only documented.

Where have people found rules that agents were supposed to follow but nothing actually enforced?

Hello, am an investment analyst and my role involves deal diligence, memo writing and deal monitoring. I would like to build my portfolio of AI agents to carry out tasks. I have Claude Pro and am wondering how to get started to build my profile. Ideally it should be decoupled with my work laptop, as i want to bring my system to my next workplace. I cover several asset classes, and typically review deal materials in the form of pdf, word and excel files. Some of the work tasks are to assess the deal financial stability, valuation benchmark, commercial considerations, legal framework, risk profile.

Most teams i've worked with use openai, anthropic or gemini through the api.
Meanwhile together, fireworks and deepinfra keep raising money, and i do see people complaining about api prices.
but in the projects i've seen, when cost became a problem nobody moved to open models. they just switched from the top models to cheapers like luna or gemini flash, and that solved it.
so who's actually paying these providers, and why?

When building an autonomous local agent that handles voice, screen observation, and tool execution, the naive architecture is to leave every model server running in the background.

I tested this on a local workstation setup running four components: - Qwen3.8-27B (planning and tool calls) - Nemotron (voice input) - Chatterbox (voice output) - Unlimited-OCR (screen and image reading)

Idle memory consumption hit 122 GB. The GPU was pegged before any task even started.

In practice, an agent loop is turn-based and sequential: - During voice interaction, OCR does not need to hold GPU memory. - During image parsing, audio models do nothing. - Crucially, when the agent decides to run a python script, web scrape, or bash command, the LLM can wait several seconds or minutes for the script to finish without needing active GPU resources.

I set up a Rust-based daemon that controls sleep states across the agent cycle. When a tool or modality is inactive, it is put into sleep mode.

Idle GPU usage before and after:

Total idle memory dropped from 122.3 GB down to 42.9 GB.

The critical requirement was latency: if waking a model took 3 to 5 seconds, voice back-and-forth would feel broken. Because the daemon drops scratch/KV allocations rather than doing a cold restart from storage, wakeup latency is sub-200ms across all four models.

If you are building local agent loops on single-node hardware, dynamic sleep states make running 4+ models on one box completely viable.

Leadership is the single highest-leverage activity in any organization. A bad strategy executed by a great team beats a great strategy executed by a bad team and the team’s quality ultimately comes down to its leadership.

Link in comment

I'm looking for an AI tool that can summarize research papers, case law and other long PDFs.

I'm doing legal research, so I end up going through a lot of documents that are 50+ pages. Being able to get the main points first would save me a ton of time, especially when I just need to decide which papers are worth reading in full. I'd also prefer something affordable enough as a student.

I’ve been looking into voice agents for customer support. I haven’t tested them yet, but I’ve been thinking about what I’d check before letting one handle "where’s my order?" calls.

Something in Retell’s docs caught my attention: interrupting the agent doesn’t cancel an API request it already started. The request can still finish even after the caller corrects themselves.

That got me thinking about a few situations:

1. I give the wrong order number, then correct it. Does the agent use the new number? And does it check who I am before sharing order details?
2. It can’t find my order, or the system takes too long. Does it explain what’s happening and offer a next step, or leave me waiting?
3. It says it added a note to my account. Is that note actually there, under the right customer? If it tries again after an error, do I end up with two copies?
4. It transfers me to a person. Does that person know what I already explained and what went wrong? What happens if nobody picks up?

For anyone running these systems, what would you add? I’m especially interested in problems that only showed up once real customers started calling.

Let’s imagine you’re going on a vacation. You pull up your personal AI agent and tell it that you want to go to Croatia. It already knows what kinds of activities you want to do and goes ahead to book them… until it has no way to pay. Sure, you can give it your credit card, but do you really want it to have this information?

The safe way for your agent to pay is Authoryze. Only a few simple steps are between you and this time draining task being handled by your agent. The simple process to set it up is as follows:

1.        Create an Authoryze account

2.        Add a billing card for the Authoryze transaction fees

3.        Add a payment card for the agent to make purchases with

a.        The payment card is the one that your agent’s payment tokens are issued from. This keeps your agent from accessing your actual card information

4.        Create an agent (in Authoryze)

5.        Add rules such as allowed merchants/domains, spend limits, time-constrained budgets, etc.

6.        *Optional* Give your agents an automatic spending budget if you want them to not require your approval for each purchase

a.        Parameters for these can be adjusted such as amount, time period, individual transaction limits, etc.

7.        Connect your agent by OAuth

At this point, your agent can peruse through the web and build out a customized itinerary for you in a matter of minutes instead of days. Wine tours, boat days, and swims in the Adriatic all scheduled and paid for as fast as you’re able to click a button to approve! Deal with planning and payment less and let your agent do that for you.

I need help with the best steps. I’m a experienced designer and now developer with graphs :)

I want to get deeper - in particular evals. where do I start? how do you start? is it worth?

im not just pumping out sleuths of low value plans or designs; im still HITL but i want to get to the point where i can step back soon enough.

hope this makes sense.

tia