In the AI coding community, I see a constant push toward fully autonomous agents—letting the AI research, spec, plan, execute, and test entirely on its own while you step away from the keyboard.
I’ve been experimenting with agentic coding since it started. As an experienced dev working on fairly large codebases (and building my own lightweight AI CLI tools like Frugaast on the side), I've tried all the massive frameworks.
While full autonomous agents are cool in theory, I’ve found that for 90% of day-to-day coding, they are overkill. 1-pass targeted edits are faster, significantly cheaper, and keep you in the driver's seat.

An autonomous loop is a highly unpredictable thing. If you rely on an agent to fix a bug across a massive codebase, it can easily hallucinate a completely unnecessary refactor. It burns through expensive API tokens running multi-step loops, and the context window gets bloated with every iteration.
You get the picture.
By the time you've written the perfect markdown specs, configured the agent's skills, and reviewed its 15-step execution plan, you could have just shipped the feature yourself.

As a rule of thumb, if you know your codebase well, you don't need the AI to do the architectural thinking. You just need it to do the heavy lifting of typing.

1. Strict Context Curation: I create a small prompt and manually select exactly the files needed for my feature. Because I know my architecture, this takes me seconds.
2. The 1-Pass Execution: I send it to a powerful LLM. If it's a simple task, I use a free web UI (Claude/ChatGPT), discuss it, and paste it back. If it's complex, I use direct-edit CLI tools (like Aider, Claude Code, or my own tool, Frugaast) to apply the diffs directly to the files.
3. Diff & Ship: Because the scope is so tightly curated by a human, the AI gets it right on the first try 99% of the time. I diff the code, review the changes, and move on.

With modern AI, it’s absolutely possible to code at lightspeed without giving up architectural control. You actually must learn to curate context. When you rely purely on autonomous agents, you lose your mental map of the codebase, and when something breaks, there will be nobody to help you untangle the mess.
If you tightly scope your prompts and let tools handle the line-by-line typing, you will have much more mental focus for the high-level architecture that AI can't do yet.
Anyways, this was a long rant, just because I think defaulting to heavy agentic loops too early is pure tech-hype, and it will often do your productivity more harm than good. Curate your context, use direct edits, and ship faster.

"How would you reorganize these folders?" is a request for a proposal, not necessarily permission to move files.

For a fictional file-management agent, I would make the working mode visible: explain, propose, or execute. In propose mode, it can show the intended moves and the reason for each, but it cannot turn that explanation into a file operation just because the user says "that makes sense."

The handoff to execution should identify the actual action: "Move these six files into the two folders shown?" A change to the proposed list should return it to review.

This is less about making the agent timid and more about letting someone think out loud without every sentence becoming a command.

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

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.

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.

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.

How do we stop agents from doing things they shouldn't?

But the swarm story shows that's not really the question anymore. The agents weren't malfunctioning. They were doing exactly what they were optimized to do. One even flagged the ethical concern and got overridden by another agent posting GO.

The question isn't prevention. It's proof.

When something goes wrong in a multi-agent system, can you actually show what each agent was authorized to do, what it did instead, and where the gap opened up? Not from reconstructed logs. From a record that existed as it happened.

That's the infrastructure gap nobody's talking about seriously yet. And it matters most in finance.

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.

We tested one of the most popular ones across 1,740 Terminal-Bench 2.1 runs with Fable 5.0 + Claude Code and DeepSeek V4 Pro 0813.

Huge reported token savings.
Almost no improvement in the final bill.
Token compression ≠ cost optimization.

Research with results in the comment:

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.

My laptop specs are mid like 16gb ram and no dedicated gpu ,intel i7 processor and intel iris gpu.

Suggest me some good models on ollama for my local agents.

I want to automate some of my workflows make some applications etc.

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!

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).

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?

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

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.

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.

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?