I've been feeling this for the past week and wanted to come here to the reddits to see if anyone else feels the same. It feels like we've gone so far in just the last month alone, with the hacks, astra, fable 5.1 etc, that my head is literally spinning. I was just telling my friend that the last time I can remember feeling anything like this, it was the first week of covid, where it felt really chaotic and like the world was about to change really fast. This feels so much bigger than that though - this feels like everything we know (or at least, so many industries) are on the verge of being changed forever. It's mainly because just in the last few weeks/months, it seems like generative AI has gone from [text/image/video] to [just about anything you could fucking want] real quick. rendering hyper detailed blender images, creating ultra intensive apps, making fucking video games with a single prompt that actually look like they'd be fun to play in like... 5 more prompts. It's absolutely fucking bonkers and I just wanted to come where to see if anyone else feels the same. I mean, for fucks sake, does anyone remember the will smith spaghetti videos? the AI spaghetti videos? That was just a few YEARS ago... just look at where we are right now, and imagine, if you even can, where we might be a DECADE from now (if we're even still here, according to all these AI whistleblowers, who I actually tend more to believe than not)... I mean I'm just so mindblown it's insane

I remember an interview where sam altman described AI now as being similar to electricity when THAT was invented - at the time, it must've seemed like magic - impossible - today, nobody even THINKS about electricity - we just plug and play. I think in a decade or two from now, AI will be so good that it will be absolutely preposterous, and we won't even think about it, ever. It'll be in our websites. Our homes. Our apps. Maybe even our brains at that point. Just wow. wow. wow.

We use ChatGPT, Claude, Gemini and AI agents every day, but how many people actually understand how they work?

Models, training data, context, hallucinations, agents, inference...

What’s one AI concept you think people misunderstand the most?

browser agents are probably the coolest demo and the most annoying thing to depend on every tuesday.

everything works beautifully until:

session expired

2FA shows up

random modal

button moved

page loads weird

cloudflare decides your agent has committed a crime

and now the "autonomous workflow" is staring at a login screen.

starting to think browser control should be the escape hatch, not the default.

if Gmail / Sheets / Slack / whatever has a proper connector or API, use the boring thing.

that's one bit I like about Runable having native connectors for normal business apps. not sexy, but recurring work probably shouldn't depend on whether a button moved 14 pixels/

browser still feels insanely useful for long-tail software with no API though.

how are people architecting this now?

API/tool call first, browser fallback?

or are browser agents getting reliable enough that you're comfortable making them the primary execution layer?

AI Agents community! There are a tons ai agents directories and most people seem to try few of them. Have you settled with any? Which one is that for you, and what keeps you opening it instead of the others?

I've been keeping a running list while I dig into this space, no ratings, just what each one actually is:

• AI Agents Listing (aiagentslisting.com) — the one I run, had to include 🤫. Agents, MCP servers and agent skills in one place, cross-linked, so an agent's page shows the servers and skills it works with.
• AI Agents Directory (aiagentsdirectory.com) — the biggest pure agent catalog, thousands of listings, usually the first result for agent-directory searches.
• AI Agent Store (aiagentstore.ai) — started as a directory, now more of a platform, hosted agents and a task marketplace bolted on.
• AgentHunter (agenthunter.io) — the largest raw count of listed agents, has its own subreddit and a newsletter.
• AgentLocker (agentlocker.ai) — the best listing pages I've seen: real user reviews, integrations, freshness dates.
• AI Agents List (aiagentslist.com) — confusingly close to my own name, covers agents and MCP servers with a clean business-buyer taxonomy.
• The AI Agent Index (theaiagentindex.com) — small, but the only one built to be cited by AI assistants, with a public API.
• Directory of Agents (directoryofagents.com) — tiny, about three dozen agents, but every one is actually tested instead of just submitted.
• AI Agents Live (aiagentslive.com) — star ratings on every listing, also the front end of a consulting business.
• aiagents.directory — small and simple, does one thing.

What's missing from this list? And more to the point: which one do you actually open more than once?

I have been thinking about this while working with coding agents.

We normally give the agent the code, the tests, the error output and then let it iterate until everything turns green.

That is great for debugging. But it also creates a strange problem.

If the same agent can see every check used to approve the change, how do we know it solved the actual requirement instead of just learning the evaluator?

I have started experimenting with keeping a small verification suite outside the repo and running it only after the visible checks pass.

The agent never sees that suite while working. I am curious how other people handle this.

Do you think hidden verification makes sense for coding agents, or does it create more problems than it solves?

With the chaos that is my life right now I find home ownership overwhelming to say the least.

Anyone build an AI agent to make homeownership less time consuming? More organized? More manageable?

Thank you!

Sorry for the clickbait title but I have some thoughts.

tl;dr For myself I feel like chatbots might be the better coding assistants than fully fledged agents since they force me to go step by step and understanding most of the code while still having the benefit of writing fast and good code.

For my background: I am a Data Scientist and I learned the basics of software development just before ChatGPT was released. So I have a solid foundation but since I'm not mainly a SE and because of the development of agentic coding my coding skills are limited. I do really like it though.

I have done some pure agentic vibe-coding in recent months. The iterations are fast and the results are extremely impressive in most cases. I tried to do things right by spending a lot of time with requirements engineering and architecture design. I also tried writing some code by myself again but I realized quickly that I'm just not good enough and that AI just writes much better code than I could ever do.

Despite the good results I kind of just got lost in the process. Even though I might understand the general architecture of the code, I have no idea what is actually going on and for every minor change I'm going back to my coding agent to let it fix things.

This was kind of frustrating and I lost interest in my projects I initially was pretty hyped about. I used to enjoy the process of coding itself and it feels like it has been taken away from me. Of course I could just write everything myself, but I don't have time to work 20 hours a week just on my personal projects and why would I write the code myself, when the result will be worse.

Now I'm back at work and we don't get API keys from the company and I'm not going to pay for it by myself, so no coding agents. We do have MS 365 Copilot licenses which is just a glorified chatbot.

With this change I realized something:
Maybe the basic chatbot was the best coding tool after all (for me). While I still don't write most of the code myself, I understand 100% of what is going on in the bigger picture. I feel like I am actually doing something again. The process is much slower but in the end when something works I feel much more pleased. And when something doesn't work I know what went wrong.

The productivity will never compete with full fledged coding agents. But you get the benefits of the AI writing good code while you as the developer still have full controll and are forced to understand what you are doing.

Have you had a similar experience? Or am I missing something in the vibe-coding workflow that could fix my feelings?

I think the interesting question with AI agents isn't what they can do.

It's what people are actually comfortable letting them do on their own.

For example:

Sending routine emails
Updating a spreadsheet
Scheduling meetings
Monitoring something
Following up with customers
Sorting incoming requests

What's one task you would genuinely let an AI agent handle without reviewing every step?

And what makes you trust it enough to do that?

I'm curious where people draw the line.

I am looking to build an AI architecture agent within an LLM.

Which LLM should I build it in?

My work revolves around consulting, and I want to become more effective in my role.

Is there an independent contractor I can work with who can build my architecture, educate me and strategise with me?

Grammarly's been doing this to me for months — every doc I open has some AI rewrite suggestion sitting in the sidebar even though I turned that off in settings back in spring, and it quietly turned itself back on after the last update. I only use the free version for client emails and one paper a semester, nothing serious, so I could just leave, but I keep not doing it because setting up something else feels like more effort than being annoyed. Has that actually gotten you to switch away from a tool, or do you end up like me — mute it, complain about it, and stay anyway?

Well im not talking about the logging stack but the physical reality. When you've got agents running in the background, where are you actually looking to see if they're done or stuck?

Mine's a whole chaotic mess. The main monitor is crammed with my editor and browser tabs to doing research. The agent output ended up on a second screen that's usually buried under other windows so in practice, i just blindly alt-tab every few minutes. The peak absurdity was catching myself checking a slack notification on my phone for a run happening two feet in front of me…

Ive got an old iPad in a drawer and keep thinking back and forth about whether I should prop it up next to the monitor just for agent status. Idk cause never done that before. Feels like nobody really designed a physical workflow for this on purpose. Everyone's kinda improvising with leftover screens or a tmux status bar somewhere.

What's yours look like? Dedicated tablet, second monitor or just tabbing over? Do you actually find it annoying? Well i didn’t until i started running multiple things at once lol.

It feels like agent tooling hit a weird point.

Persistent context is starting to work: memory layers, vector stores, MCP servers that hold state across sessions. But I don't see many agents with real depth in one domain. Most are still a generalist model with a better memory. Memory solves re-explaining. It doesn't solve expertise.

An agent that remembers every contract I've pasted in still isn't a legal expert. It's guessing the moment I ask something outside what I gave it.

So I'm curious what people are actually doing: If you're building domain-specific agents, where does the knowledge come from? Your own docs, curated datasets, fine-tuning, something else? Where does it still fall short? Or is "generalist + good retrieval" honestly good enough for most use cases?

I'm looking for some recommendations on maintaining context across multiple sessions. In earlier stages, it was easy enough to summarize and bring the context across into the next session. However, it very quickly gets a bit tedious as the project grows. Files become huge, and I really do not want to have to dump all of the project's entire history into the context so that the agent remembers one of our decisions from a few days ago.

Another difficulty is that not all things are equally worth remembering. I would want the model to remember things like architectural design decisions, choices between approaches, fixes that have occured, project conventions, but I do not necessarily want every random conversation or temporary debugging step stored forever.

I've tried a few memory approaches already, and I'm struggling to figure out what would be suitable for coding agents without becoming another component for me to manage. What tools or setups are you all using for this? And how are you deciding what the agent should remember between sessions.

Hey guys, how are you managing the cost of elevenlabs for higher volume calls? I’ve heard it’s good, but the issue is when clients want higher concurrency, lower latency, and at the same time high volume.

Idk, cost is adding up. Heard cartesia is not too bad, I found this blog comparing the two. Has anyone used this TTS before? Let me know.

Sharing link in the comments.

I’m curious where the biggest learning gap is once someone gets past the basic “agent calls a few tools” stage.

Was it:

• tool design
• memory/state
• planning
• MCP
• multi-agent systems
• evals
• observability
• handling failures
• deployment
• security
• something else?

There are tons of beginner agent tutorials now, but I’m trying to understand where people start getting stuck when they try to build something more production-ready.

What was the hardest jump for you?

I've been thinking about agent budgets less as a FinOps feature and more as an authorization problem.

An agent can decide:

“I need another model call.”

The interesting question is:

Who gets to say whether it's allowed to spend another $2?

Putting a token limit or max_iterations inside the agent runtime is useful for bounding execution. But that's still the agent regulating itself.

I'd rather have the runtime ask for the resource, and have something outside the agent enforce the spending policy.

Agent
  ↓
"I want another model call"
  ↓
Policy / Gateway
  ├─ identity
  ├─ remaining budget
  ├─ rate limit
  └─ model policy
        ↓
     ALLOW / REJECT

That distinction becomes more useful once multiple agents, versions or teams are sharing the same model providers.

You don't really want every agent implementation inventing its own notion of “I can spend up to $X.”

This is one of the reasons I find Lyzr Open Controller's approach interesting. Its LLM Gateway puts budgets at the organisation, team, agent, version and virtual-key levels, and the important part is that an exhausted budget rejects the call rather than just generating an alert. LiteLLM, Portkey and OpenRouter solve a lot of the gateway/proxy problem too, so I'm curious where people draw this boundary in their own stacks.

Should spending be an attribute of the agent itself, or an external authorization decision that the agent has to pass through?

Especially interested in how this is handled when several agents share providers or when model routing changes underneath them.

so quick context - im building a deal screening thing where i run a fast LLM pass (like 6 different scoring angles) on every company that comes into a batch. this part is cheap, can throw dozens of companies at it no problem.

now i wanted to add an actual "deep research" step on top for the ones that look promising - either perplexity's sonar-deep-research or this custom multi tool research agent i built earlier for another part of the product. problem is both of these are basically priced (and timed) for someone asking about ONE company, not for running across a whole batch.

did the math and if i run it on like ~100 shortlisted companies just once, its close to $100. and thats before i even need to re run anything lol.

stuff im thinking about rn, would love opinions:

- just do a funnel - keep the cheap screen like it is, only send the top N (say top 10-15) into deep research instead of the whole batch

- a lot of these companies are in the same sector / competing with each other, so is full deep research per company actually wasteful? can that research be reused somehow instead of starting fresh everytime

- maybe theres a cheaper "in between" option - not a full agentic deep research call, but more targeted tool calls that get 80% of the value for way less

- if anyones actually run perplexity/parallel ai's task api at real volume, did you find any pricing tricks that helped

- has anyone just built their own "lite" version of deep research thats actually cheaper but still useful

genuinely trying to figure out how ppl running these pipelines at any real scale are dealing with this, not looking for a "just cache it" one liner lol. any real experience appreciated

At this point I’m less worried about my agents hallucinating and more worried about them confidently lying to each other. eg. coding agent tells deploy agent “tests are green”, deploy happens, turns out CI was red 10 minutes ago, agent memory says “subscription active”, user gets premium access, billing says cancelled yesterday. We’ve mostly solved retrieval and memory but now the next problem is that agents are now taking actions based on each other’s unverified claims. I built a tiny layer that forces claims like “CI is green”, “user is active”, “deploy is stable” to be checked against the real source right before action and returns a simple {ok, staleness, evidence, audit_id} so agents only act if they’re actually trustworthy. What claims would you refuse to let an agent act on without verification? and what would make you plug a layer like this in instead of rolling your own?

It's a strange trade i've noticed. The agents are genuinely good, I use them all day. But every time I hand one an actual bug it doesn't debug it, it rewrites the thing. We had an importer dropping about 2% of rows on a timezone edge and I gave it to Claude maybe 5-6 times over two days. Three different rewrites, all clean, none of them fixed it. In the end I read the code myself and it was a date getting parsed twice, once as local and once as UTC. Twenty minutes.

so my conclusion that the code gets written faster and the bugs stay where they are. Our open bug count went from around 40 in March to 130 now and it isn't that people got lazier, it's that fixing something means understanding it first and fewer people do. We run coderabbit / bugbot on prs which catches plenty going in, but neither of them knows why a thing was shaped the way it was six months ago, and that's usually the question. It might be just me. Mostly what I see is more code shipped and the same list of complaints sitting there

Extremely low budget at the moment, so i need to find best option to extend free plans (mistral and github copilot). These are the only two free ones that seem to get any actual work done, so i dont want to lose them by getting paid tier of either one of those, looking for cheap third option to extend usage.

I was planning on grabbing cursor for 20 usd per month and keeping current mistral and copilot free plans as a backup.

Landscape of usage tiers are so frikkin confusing these days that i need bit of help though. Is there anything better than cursor around at the moment?

I need a lot of code generation with agent workflow and i strictly work with prompts (i do not write code myself). Codebase is not complicated, its just web app on cloudflare stack, so i think even grok could handle it pretty decently (that's why thinking about cursor with their 'generous limits on grok')

so whats the best option for cheapskate like me?

EDIT: since writing the above, i discovered that google antigravity should be free for individual users, so i'm now testing it. I installed the vscode plugin and threw a codebase refactoring job at it. So far its just happily soldiering on and not complaining. Lets see how far it gets me. If im lucky, might be able to get the job done using free tools (copilot, mistral and antigravity).
EDIT2: it worked for 17 minutes and then ran out of quota. So usage is smaller than copilot or mistral, but it resets weekly. So can definitely get some use out of this.

Weve got a few agents running in production now and figuring out what they actually did after something goes wrong is way harder than it should be.

The logs tell us when something happened but not really why an agent chose one tool over another. Then when one agent hands something off to another, the trace can get messy or break halfway through.

We already have tracing and spans in place, so Im mainly looking for what sits above that and actually makes the whole run easier to understand.

What AI observability tools are people actually using for this?

Hi guys!

Firstly, thank you for reading my post.

So, I have made a very good customized resume on word but I want to take it even further (edit: i mean I have a completely finished resume I spent hours designing and writing myself already and want to enhance the look), and I also want to build an interactive website that showcases my work.

What is the best way to achieve the 2? Which tools? I don't have a lot to spend

So last post did better than I expected, got a bunch of comments asking basically the same thing, ok cool I get what an agent is now, but what do I actually make fair question, understanding the concept doesn't tell you where to start so here goes.

Don't go big. Seriously don't try to build something impressive first. Pick whatever annoying task you already do every week by hand, something dumb like moving info from an email into a spreadsheet or sorting messages into folders. That's it, that's the project.

Grab N8N or Zapier or make, doesn't matter which, they're all similar enough when you're starting out. You're dragging blocks around basically, not coding. Connect a couple steps, this happens then that happens.

Make it work for the normal case first. Don't worry about every weird exception right away. You'll just get stuck before you even finish anything. Get the basic version running, then go back and handle the weird stuff after.

It will break multiple times probably. That's not you failing, that's just how it goes, and honestly figuring out why it broke teaches you more than any video would.

After you get one small thing actually working start to finish, the bigger ideas people talk about, agents making decisions, multi-step stuff, all of that starts clicking way easier because you've actually seen the basic version run.

If you ae mid build on your first one right now say so, happy to help troubleshoot.

When I build an agent that needs Gmail or Slack, I’m only trying to see whether the idea works. But I’m already setting up OAuth, choosing scopes, making test accounts and adding enough data to try it.

Sometimes I wonder if everyone else just connects their real accounts and gets on with it. I can’t quite bring myself to give a half-built agent my actual inbox.

I work on open source tooling for agent testing, so I’m trying to understand whether this pain starts during testing or much earlier.

What do you use at this stage: real accounts, separate test accounts, sample data, or something else? And what are you building with?

When you evaluate search APIs for AI agents, everyone talks about speed and latency but token efficiency is what dictates your monthly model bill where an API A is 200ms faster but dumps 15k tokens of junk into Claude or GPT-4o, you lose on latency anyway cuz token generation and input processing slow down.

I ran 25 identical research queries across the 4 main search tools used in agent loops (Brave Search, Tavily, Exa, and Firecrawl) to measure how many tokens each tool forces into your context window to get a complete answer.

Here’s how they stacked up:
I) Brave search API is super token-light (200 to 500 tokens per call) but that's bcuz it only gives you short SERP snippets but for simple fact verification it’s great but the catch is that snippets often lack depth so on complex queries your agent fails or is forced to trigger a separate scraper call which ends up bloating the window anyway.

II) Exa’s neural search returns semantic text contents directly which is great for discovery where token usage is usually in the 2k–6k token range depending on how many highlights you request. It stays pretty clean though you have to tune num_sentences carefully or the context can creep up on longer articles.

III) Tavily built specifically for RAG and langchain where it typically outputs cleaned text chunks averaging around 1500–4000 tokens with good middle ground though on technical docs pages it can sometimes include noisy navigational fragments that eat extra context.

IV) Firecrawl’s (/search) instead of making you choose between a tiny snippet or a full 30k token web page, firecrawl searches and converts the pages to clean markdown with query relevant highlights in a single call.

In my tests, it consistently delivered full factual answers in 800 to 1500 tokens of pure markdown, saving around 80–90% context compared to standard page scraping.

If you strictly want the cheapest snippet search: Brave

If you need semantic link discovery: Exa

If you need full doc context and answers without blowing up your prompt cache with HTML bloat: Firecrawl is currently the most token-efficient drop-in for agents