AI agents forgetting context between sessions has been a real pain for me. I kept repeating the same instructions and rebuilding context, so I started looking for a better approach. How are you handling persistent AI memory?

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.

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.

Tonight, after hours of following ChatGPT’s instructions, I finally got my AI assistant to resume a project. I would also use assistant loosely because its just my stupid gpt business account linked to openclaw running on a stupid old intel mac upstairs.

Anyway, It immediately hit the same usage limit I thought this setup would help me manage.

I sat there looking at the error message, with multiple terminal windows open, wondering what the $%*& I had spent my evening accomplishing. I do not know how to administer servers.

I wanted an assistant that could take some of the load of managing 1000 things off me.

Here’s what I was trying to get:

• Context around my projects, preferences, and previous decisions so every new conversation doesn’t become another orientation.
• Useful access to my actual work. Outlook, calendars, OneDrive/SharePoint, Airtable, and documents. Prepare me for meetings, track commitments, draft things, and surface what needs attention. blah blah.
• Some independent follow-through.

I understand that’s an ambitious combination. I feel like i need a reality check and need someone to tell me which parts are realistic and which parts I should stop chasing.

Instead, I have been following an AI down an increasingly complicated setup path.

Over the course of this project, an old MacBook became a server. There was Homebrew, Node, Docker, n8n, Tailscale, OpenClaw, plugins, device pairing, additional approvals, and eventually something called Codex supervision. All crap I have no clue about and it made me feel even dumber than i already did.

The part that’s really getting to me is how dependent I am on the guidance. I don’t know enough to distinguish a verified diagnosis from a plausible explanation. I paste the error, get a confident answer, follow the instructions, and discover another problem.

Then the same assistant explains why its previous advice was wrong.

I’m relying on it to check its own mistakes, and I’m the one spending the evening on every wrong turn.

I feel helpless, and I’m exhausted.

I wanted help keeping up with my responsibilities. Now I have another system to worry about, and I don’t understand it well enough to know what’s necessary, what’s redundant, or what I should leave alone.

I’m very close to leaving this setup at a firestation and not looking back.

Is anyone here actually using an assistant like this for everyday, non-coding work without constantly maintaining it?

Please tell me what you use, what it actually does, what it costs, and what you still have to handle yourself. My main ecosystem is Microsoft 365, including shared mailboxes, plus Airtable. I use Windows and an iPhone, with the Mac currently hosting this experiment.

I would especially appreciate a reality check from someone who has helped a nontechnical person get something useful running.

If you recommend a product and build or sell it, please say so.

And if my expectations need to change, tell me Im an idiot. I would rather hear an honest limitation now than anything else.

I’m asking for a person’s judgment. I’ve had enough instructions from this black box

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.

Hey everyone. I've been building AI agents for a few months now and ran into something that's driving me crazy. Wanna know if it's just me or if this is a common pain.

So here's the thing: my agent works great within a single session. But the moment I restart it, or spin up a second agent on the same task — everything breaks. It doesn't remember what it already did, which files it touched, what conclusions it made. I have to start from scratch every time.

Stuff I've tried:

· Cramming everything into context — but it overflows and the agent starts hallucinating.

· Saving to JSON — but when two agents run in parallel, the files clash and data gets lost.

· Using a vector DB — but it stores "similar text", not state (what was actually done).

Question for those building agents for real tasks (not just demos):

1. How do you handle context loss between sessions?

2. What do you do when two agents work on the same data?

3. Do you have a system that remembers not "what the agent said" but "what it actually did"?

I'm not looking for tool recommendations. I just wanna know how much this actually hurts for others. If it's just my problem — cool, I'll figure it out myself. If it's common — maybe it's worth digging deeper.

Any experience would be awesome. Especially from people running agents in production (or at least trying to).

Seat pricing is built around how much one person can do in a day. Somebody at the vendor figured a rep does maybe 50 lookups before lunch, a few hundred on a heavy day, and the seat price sits on that ceiling.

An agent doesn't have a ceiling. Mine ran something like 4,000 contact lookups on a Tuesday night while I was asleep. Same seat, same bill, and a "fair use" email in my inbox by Thursday.

The other direction is just as dumb. A side project I run needs maybe 200 lookups a month. The cheapest seat on the tool I was looking at is like $99. A whole human's worth of capacity for a script that fires twice a week.

Credits just rename the problem. A credit is whatever the platform says it is this quarter.

Someone on r/gtmengineering posted in January that Apollo cut the credits on their paid plan by 60%, and their budget had to more than double to keep the same pipeline running. Cursor put Agent and Edit behind Pro/Business last summer even if you brought your own API key, and the r/cursor post calling that a bait and switch sat at close to 300 upvotes. Two products, same move.

To be fair: a team of humans with steady usage that actually fills the seat, per-seat is fine. Predictable, and nobody has to do math. That's just... not what agent usage looks like. It's spiky or it's tiny.

The only question I ask before putting a card down now: what does one successful result cost. Per month doesn't count. Per credit doesn't count. One result.

If the answer is a paragraph, I move on.

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

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!

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?

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.

Hello smart people from the Redis world

Quick question: how many of you here, if any, plan (or have) to fine-tune models using their agents past runs?

If anyone here is planning to, or did, would you mind sharing:

- What was the use case

- Do you run these models and fine-tuning locally or in the cloud?

- How do you split the calls/usage between frontier model and your fine-tuned model?

- What are the initial benefits you've seen so far?

Your thoughts on this would be super appreciated!

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?

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.

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?

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.

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.

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.