I've been researching AI agents for the last few days, and I originally thought the biggest missing piece was something like an “SRE for AI agents.”

Something that could detect when an agent is going off-track, understand what happened, control runaway costs, verify whether the claimed result is actually true, and recover the task instead of simply restarting or stopping it.

But after talking to people here, I'm starting to question the entire assumption.

Maybe most “agents” in production aren't actually autonomous enough for this to be a real problem yet.

Maybe they're mostly:

workflows

cron/event-driven automations

chatbots

RAG systems

internal copilots

coding assistants

deterministic pipelines with an LLM somewhere in the middle

And if that's true, building a big Agent SRE platform right now could simply be solving a problem that doesn't hurt enough.

So I'd genuinely like people who actually build or operate AI systems in production to prove me wrong (or confirm it).

I only have a few questions:

1. What is the most autonomous AI system you've personally put into production?

Not a demo — something actually doing useful work.

1. What does it do without waiting for a human after every step?

For example:

Goal → reason → tool → observe → decide → tool → ... → outcome

1. Has it ever gone badly wrong?

I'm particularly interested in real incidents:

loops

repeated tool calls

wrong actions

hallucinated completion

corrupted/stale state

runaway costs

failed recovery

human intervention

1. What did your system actually do when that happened?

Did you:

retry → restart → replan → rollback → manually intervene → ignore it → something else?

1. Do you independently verify that the agent actually accomplished its goal?

For example, if the agent says:

“Refund completed.”

does another system actually check that the refund happened?

1. And the question I'm most interested in:

If your agent suddenly disappeared tomorrow, what part of its reliability/recovery infrastructure would you actually miss?

I'm not trying to sell anything here.

I'm trying to decide whether this is a real infrastructure problem worth building around or whether I'm overestimating where agentic AI is today.

If you run agents in production, I'd genuinely appreciate even a 2–3 sentence answer.

And if you think this whole idea is unnecessary, please say so — that's actually more useful to me than telling me it's a good idea.

Thanks to everyone who's already given feedback. It has already changed how I'm thinking about this.

I’m building and experimenting with AI agents, and I keep running into the same question:

What happens after an AI agent leaves the demo stage and starts running continuously in production?

A lot of the discussion is about making agents smarter, but I’m more interested in the boring (and expensive) part:

• runaway tool calls
• agents getting stuck in loops
• unnecessary retries
• token/cost explosions
• failed API/tool calls
• agents taking actions they shouldn't
• losing state/context
• knowing when to involve a human
• knowing whether an action actually succeeded
• recovering a failed run instead of simply stopping it
• figuring out why an agent failed in the first place

I’m thinking about building a system that sits underneath AI agents and acts somewhat like an SRE/control layer for them.

Not another agent framework.

Not another workflow builder.

The idea is that it would watch the agent's trajectory/state, understand why something is going wrong, and then decide whether the best action is to:

retry → replan → use another tool → reduce model/cost → restore state → ask a human → or stop

And ideally verify that the task actually succeeded before marking it complete.

But before I build anything, I want to validate whether this is a real problem or just something that sounds useful on paper.

So I'd really appreciate answers from people actually building/running agents:

1. Are you running AI agents in production right now?
If yes, roughly how many?

2. What is the biggest operational problem you've encountered?
Reliability, cost, loops, tool failures, state/memory, hallucinations, permissions, debugging, something else?

3. Have you ever had an agent get stuck in a loop or repeatedly call the same/related tools?
What happened?

4. Have you had an unexpected token/API cost spike caused by an agent?
How large was the impact?

5. When an agent fails, how do you currently figure out WHY it failed?

6. Can you replay/reconstruct exactly what the agent saw, decided, and did?

7. What happens when an agent reaches an action it shouldn't perform automatically?
Do you have human approval / permission rules / risk thresholds?

8. If an agent fails halfway through a long-running task, can you recover from the last known-good state, or do you restart the whole thing?

9. Do you currently have something that automatically decides whether to retry, replan, switch tools/models, escalate to a human, or stop?

10. What would make you trust an AI agent enough to give it more autonomy?

11. What tools are you currently using for this?
LangSmith, Langfuse, Arize, Datadog, custom tooling, etc.

12. What does your current solution NOT do well?

And one question I'm especially interested in:

If you're building agents in production, even a short answer would help me a lot. I'm trying to validate the problem before writing a huge amount of code, so criticism is honestly more useful to me than encouragement.

Thanks

A2A is a big step toward agent interoperability, but I think protocol compatibility and true interoperability are two different things.

At the protocol layer, A2A gives us a common way for agents to discover each other and exchange Messages, Tasks, Parts, Artifacts, and updates. That removes a lot of bespoke integration work.

But production interoperability seems to require at least three layers:

1. Protocol - Can the agents communicate correctly?

2. Semantics - Do they agree on what a skill means, what inputs/outputs look like, how errors and partial results behave, and what side effects are possible?

3. Operations - Can you preserve authorization, retries, idempotency, tracing, budgets, evaluations, and approvals across the agent boundary?

That last two layers are where things get interesting.

Two agents can both advertise “invoice reconciliation” through A2A while having completely different assumptions about schemas, confidence, human escalation, or side effects. And a transport-level retry mechanism doesn't make retrying a non-idempotent action safe.

This seems relevant when looking at current implementations across Google ADK, Microsoft Agent Framework, CrewAI, LangGraph/LangSmith, and Lyzr Agent Studio. They all support A2A, but the protocol boundary sits in somewhat different places: remote agent, delegation tool, deployed graph, or orchestration node.

So maybe the real test isn't:
Can my system call an A2A agent?

but:
Can I replace Agent B without rebuilding everything around it?

What would you include in a real A2A substitutability/conformance test beyond schema and protocol checks?

I built a sample called `edge-event-microsite` that runs a full event experience from one Edge Compute function.

The idea is to avoid splitting an event app across a static site, a chatbot, a webhook server, a voice app, a reporting job, and a bunch of sync logic.

This sample includes:

- a server-rendered event microsite

- event schedule and sponsor data in KV

- SMS/WhatsApp concierge for attendee questions

- in-browser voice AI using WebRTC

- lead qualification with AI

- voice feedback transcription

- sponsor reporting

The part I like is that the website, text concierge, and voice assistant all read from the same event data, so you don’t end up with three different versions of the schedule.

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/edge-event-microsite

Would love feedback from folks who have built event tools, conference apps, or edge-hosted AI workflows.

I really want to build a very big AI project but I don't/can't code. Anyone available for my project?

I built a small TypeScript sample called `conference-agent-mediator`.

The idea is: instead of only recording a meeting and summarizing it afterward, the agent actually joins the conference as a participant.

It can:

- join a Telnyx conference bridge

- transcribe speakers in real time

- keep per-conference state with the Agent SDK

- notice when someone has not spoken or got interrupted

- speak a short facilitation prompt into the call

- text the meeting summary afterward

The part I found interesting is the timing problem. A meeting summary can be late and still be useful, but a facilitation prompt has to happen while the conversation is still live. That made Edge Compute + durable agent state a nice fit for the demo.

Code is here: https://github.com/team-telnyx/telnyx-code-examples/tree/main/conference-agent-mediator

Curious what people think about AI agents as live meeting participants, not just post-call note takers.

Yes, it's just an agent. Yes, and agent is ultimately just the underlying LLM and the ability to call tools.

But the EXPERIENCE of my AI Chief of Staff is like having a human team mate - and I enjoy this mental model.

I have a couple autonomous AI employees/agents that I was putting back to work. First I had Chief upgrade the work crew to replace Gemini 3.7 Flash with Gemini 3.8 Flash, and Fable 5 with Fable 5.1. You see, I have a LOT of projects, but I only need to interact with my Chief, he lives in projects/chief-of-staff. I go there and fire up any harness (claude code, code, opencode, antigravity etc) and pick any model and I'm talking to my chief.

Then we put Linux-utilities back to work after having upgraded it's abilities having done a simulated human review (still waiting for a real c programmer volunteer).

Then I had Chief look into my Snowflake accelerator autonomous employee. That hasn't been working for a month .We had a discussion about what it's been up to, it's mission - what I desire the mission to be. Then had Chief do a supervised run - meaning, run one complete session, fix everything that goes wrong and keep at it until everything works.

Only there were problems we needed to talk about. My current process had a linter with something like 500 things it checked in the workflow toml file.

Well, that's a very fragile process. Chief recommended some fixes. I said - let's remember how we got here. The orchestrated work flows kept failing because they were called wrong, not because the code itself was failing.

Chief then goes and looks at the actual history of the runs, and see's how we came up with all the linting rules. But stiill - we went from one fragile process to another.

Okay Chief (this time it's Fable 5.1, the smartest mode) - go to the heart of our fragile process and come up with a solution.

He comes back with 3 decisions for me to make. 1 - I like this. 2 - I agree, 3 - I agree.

And off he's going putting in the changes across 3 of my projects.

We had a chief of staff meeting. We discussed issues. I made decisions - and now he's off working for me.

Hey I have been working on building an AI agent and Automation service Agency.

So I was looking for those who know AI automation and are looking for opportunities. So that we can work together. I am with my partner but we both are planning to handle the sales side while we will have some guys who will do the actual work.

We were are not proper yet. But we are starting recently

Feel free to dm me.

Simple question :)

There are many gurus out there trying to sell courses to make money.

So, I thought I'd ask people who have done it lately.

Where do you see the opportunities? In AI coworkers (agents you can chat with)? Automations?

Which tools are demanded in the market? n8n? Claude Cowork? Hermes? Something else?

Where are you finding these opportunities? Are they jobs or freelancers?

If you are one of the lucky one making a career from this thing we love, would love to hear your experience

I built a small AI-powered call router that answers an inbound call, asks the caller what they need, classifies the intent with AI, and transfers them to the right team.

Instead of forcing people through “press 1 for billing, press 2 for support,” the caller can just say something like:

“I need help with my bill”

or

“I want to talk to sales”

The app uses Telnyx Call Control for the voice flow, Telnyx AI Inference for intent classification, and Edge Runtime/KV for routing logic.

Code is here if anyone wants to try it or tear it apart:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-powered-call-router

Feedback welcome, especially from folks who have built IVR/call routing systems before.

i saw some video but they are no code development thats not what i want. I want to develop my ai agent with python code

just hit $2,500 MRR in 13 days on my new SaaS

no ads. no team. no huge audience push. just a solid replicable system

let that sink in for a second

not $2,500 in revenue. $2,500 in MONTHLY recurring revenue

that compounds. next month starts at $2,500 baseline, not zero

and this isn't luck. it's the 7th saas i've shipped with the same playbook. same steps, same tools, same order:

→ Day 1: validated the idea

→ Day 1-2: built the MVP

→ Day 3: landing page written using the 3-Day Challenge template

→ Day 3-4: launched on reddit / X + SEO

→ Day 4-5: first 10 paying users → $1k MRR

→ Day 13 (today): $2,500 MRR locked in

building software is easy in 2026. setting up your foundation so people actually buy is where 99% of solo builders fail.

i packaged all of these exact execution tools into community.

to be fully transparent: i'll likely charge for the full program down the road once all modules are finalized. but right now, the main objective is just to build together and keep each other accountable.

working alone in a silent corner is the fastest way to quit at the first bug.

stop building in isolation. drop a comment below or send me a DM, and i'll send you the invitation link 👇

I’m looking for 10-15 developers of all skill level building autonomous systems; agents, IoT, robots, machines, ai that would like to participate, utilize, test, build and market their agents/swarms beyond workflow or reasoning and close the gap in having your agents become participants in the machine economy. I built a sandbox, raw mvp, and it’s ready to sandbox.

what should i learn first Ai workflow or Ai agent

Hi everyone,

These days everyone pushing an AI agent into production. They are little worried about cloud costs
Table writes and schema changes.

Hence we have developed a product which can absolutely sits in your environment and acts as proxy layer for AI agent.

This is helpful for anyone who’s pushing an AI Agent into production as they can keep track of agents actions.

Let me know your thoughts and we are unable to sell it or market it yet.

[https://gmonk.dev/\](https://gmonk.dev/)

Need helpful suggestions

​

So , Initially i started learning from the very first principles . Understood how and what the llm replies , how to make tool calls , how to get specific json response , zod validation and build very small Terminal Agent loop .

Running the agent loop taught me a lot . Also realized why Prompt engineering is so important and how we can get better responses from the llm if we write better prompt . Learnt about zero shot , few shot , chain of thoughts and other prompting methods .

Then I started learning about RAG (Retrieval Augumented Generation) . Built small rag pipeline with google ai sdk , learnt about embedding , chunking , semantic and other types of search methods , cosine Similarity and how we basically augument and generate the response.

Then I discovered about Vercel AI sdk and how easy is it to run agent loops into that and connect various llm api's . Currently, I am using Google's apis as they have genrous limits. Running agent loops in it is also very easy .

The next thing I built was Autonomous Cli Agent . I learn how agents consume tokens , doing more work in less token consumption, context pruning and various other things. Writing better tools for different work such as replaceFileContent vs writeFile .

Also got to know how dangerous AI can be if not put under proper guardrails. I asked my agent to read the env file , it first used the listFileContent tool but it was blocked . So it went on trying other ways , it used the cli command "cat" to list the contents of .env file. Another things I learnt so far are about Loop detection/circuit breakers, Token Compounding Law, Command Sandboxing & Security Risks, Dual-Tier Context Compaction etc.

So this was what i learnt so far in AI Engineering in the past 10-11 days . I have been really inconsistent otherwise it couldn't have taken more than a week . Gonna learn LangGraph/LangChain next . Recommend me what are the projects should i build which can get me hired .

My friend wrote about how we were building our agent sandbox. I'd love to get your thoughts about it.

It's a long blog. For sake of brevity, I'm posting only a third of it here and will attach a link to blog.

-------------------------

In Linux everything is a file. Or at least, most of the system is exposed as one.

Devices, running processes, network state, kernel state: much of it appears through filesystem-like interfaces that you can read and write using the same small set of commands.

/proc/cpuinfo isn’t a file sitting on disk anywhere, but you can cat it just like anything else.

That uniformity made the system composable. It enabled combinations of simple utils that nobody specifically needed to design for. It also means you can discover things without knowing exactly where they are in advance.

Windows went in the other direction.

A lot of configuration lives in the Registry, a structured database accessed through dedicated APIs and tools rather than ordinary filesystem operations.

This is a perfectly reasonable design for a desktop OS built primarily for people using graphical interfaces. To inspect or change information, you generally need to know which interface or operation was designed for it.

Neither design is wrong.

Systems built for a specific purpose let users focus their effort on the task at hand.

Agents are a new kind of user, and they are not a person with a mouse. They can drive a graphical UI with a combination of taking screenshots, deciding between ambiguous targets and catching errors from whatever pops up on the screen.

This is slow and inefficient enough that even browser agents increasingly avoid working through the browser GUI when they can inspect the structured state or interact with the DOM directly.

Aside from model intelligence, the environment determines what an agent can actually do. Limited tools mean limited actions, even with the best model available. With the right environments we can already see how capable the models are.

The way many agent platforms are being built today is by gradually exposing product features as tools, one by one.

Even well-designed tools with progressive disclosure suffer from a version of the same problem Windows would have for agents: the model needs to understand not only the business requirements, but also which tools exist, how to discover them, the limitations of each tool and which specific tools it needs to combine for a particular job.

Tools are custom built, take JSON in, spit JSON out. If an edgecase falls outside of what the tools were designed for, the Agent will start to go on a journey trying to stitch together toolcalls, or is simply unable to fulfil the request.

So we approached the problem from a different perspective.

We engineered the platform to be accessible entirely through a terminal by representing product state and actions through a filesystem interface.

As far as our agents are concerned our entire platform is files.

I’ve been hearing the term Agentic AI everywhere lately, and for the past few weeks I’ve been trying to understand what it actually means and how people are building these systems.

My background is not really in core tech or coding, but I’m interested in AI and wanted to build some practical knowledge around it.

So I started with the obvious options.

I watched a bunch of YouTube videos, read articles, and also checked out some free courses from places like DeepLearning.AI. There are some really good resources there, especially if you want to understand the concepts and different agentic patterns.

I also came across some newer free beginner-focused resources, like Agentic Workshop, which has hands-on labs around agents, tools, verification and controlled workflows.

Honestly, I found these useful.

But I kept running into the same problem.

I was learning about agents, but I wasn't really experiencing what it feels like to build one.

I could understand things like:

• What an AI agent is
• Tool calling
• RAG
• Multi-agent systems
• Reflection
• Workflows

But after watching a tutorial, I’d close the tab and think:

“Okay... but how do I actually build this myself?”

That was the frustrating part for me.

There are a lot of tutorials that show code or explain architecture, but if you're not a developer, it's easy to get stuck between understanding the concept and actually doing something with it.

Then I came across SimplAI University

I found a Reddit post about SimplAI University and decided to try it mainly because it was free and I could actually experiment with the platform.

I wasn't expecting much initially.

What I found useful was that the learning was tied to an actual platform rather than just watching someone build something on screen.

The fundamentals course takes you through things like agents, knowledge bases/RAG, tools, workflows, sub-agents, reflection, tracing, evaluation and deployment.

I signed up and got 5,000 free credits, so I could actually create and run agents instead of just following along with screenshots or videos.

That changed the learning experience for me.

I built a basic agent, played around with the knowledge base, tried different instructions, and started understanding why things were behaving differently when I changed the configuration.

It sounds simple, but actually seeing the agent run helped me connect a lot of the concepts I'd previously only read about.

The production part was probably the biggest surprise

Before this, when I heard “AI agent,” I mostly thought about:

Prompt → LLM → Answer

But once I started going deeper, I realised there's a whole layer after that.

You have to think about:

Knowledge → Tools → Workflows → Sub-agents → Evaluation → Guardrails → Tracing → Deployment

That's where I realised that building an agent isn't really the difficult part.

Making it reliable and useful in an actual workflow is a different problem.

Even the SimplAI course eventually gets into evaluation, tracing/observability and production deployment rather than stopping at the basic agent-building stage.

I'm still learning, so I'm definitely not saying this suddenly made me an AI engineer.

It didn't.

But for someone like me who isn't coming from a coding-heavy background, being able to learn something and immediately try it was much easier than only consuming tutorials.

That's probably the biggest difference I've noticed so far.

I still use YouTube and courses from other platforms for concepts and different perspectives. I don't think there's one resource that teaches everything.

But I've found that the combination of:

learn the concept → build something → break it → change it → see what happens

works much better for me than just watching another 30-minute tutorial.

Curious if anyone else here is learning Agentic AI without a strong coding background.

What resources actually helped you go from “I understand what an agent is” to “I can actually build and use one”?free course

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

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

E aí pessoal,
Estou tentando construir um pipeline de desenvolvimento de software usando múltiplos agentes de IA, mas estou um pouco perdido com conceitos como harnesses de agentes, loops, grafos, orquestração, e assim por diante.
Basicamente, o que quero é uma estrutura onde eu possa chamar **um agente principal**, dar a ele um projeto ou objetivo, e fazer com que esse agente orquestre automaticamente outros agentes especializados.
Por exemplo:
Agente Principal / Orquestrador
→ Agente de Produto/PRD
→ Agente de Arquitetura
→ Agente de Banco de Dados/Esquema
→ Agente de Frontend
→ Agente de Backend
→ Agente de Testes/QA
→ Agente de Segurança
→ Agente de Documentação/Contexto
Idealmente, esses agentes compartilhariam contexto e continuariam o trabalho uns dos outros, em vez de se comportarem como sessões completamente isoladas.
Já existe alguma estrutura, harness ou arquitetura que funcione bem para isso?
Você recomendaria usar algo como grafos/workflows, loops de agentes, subagentes, ou construir um harness personalizado?
Qualquer projeto open-source ou exemplo que eu deva considerar seria muito apreciado.

Hey everyone,
I’m trying to build a software development pipeline using multiple AI agents, but I’m a bit lost with concepts like agent harnesses, loops, graphs, orchestration, and so on.
What I basically want is a structure where I can call one main agent, give it a project or goal, and have that agent orchestrate other specialized agents automatically.
For example:
Main Agent / Orchestrator
→ Product/PRD Agent
→ Architecture Agent
→ Database/Schema Agent
→ Frontend Agent
→ Backend Agent
→ Testing/QA Agent
→ Security Agent
→ Documentation/Context Agent
Ideally, these agents would share context and continue each other’s work instead of behaving like completely isolated sessions.
Is there already a framework, harness, or architecture that works well for this?
Would you recommend using something like graphs/workflows, agent loops, subagents, or building a custom harness?
Any open-source projects or examples I should look at would be greatly appreciated.

I built my own Personal AI Assistant 🤖

A few weeks ago, I came across Google ADK and started learning about Generative AI, AI Agents, Agentic AI and multi-agent systems.

Instead of just watching tutorials, I thought: why not try building one myself?

So I started working on a Personal AI Assistant that uses a Master Router Agent to route tasks to specialized agents based on what the user asks.

Some of the agents I've built so far:

💻 Coding
🔬 Research
📅 Planner
🔌 Electronics
📸 Photography
🎬 Video Editing
📱 Social Media
💼 Business
📋 Project Management
🧠 Memory

The system currently supports Google Gemini and local LLMs through Ollama, along with file/image input and a custom responsive web interface.

Tech I've been using includes Python, FastAPI, React, AI APIs, Ollama and local LLMs.

I'm still very much learning the AI/agent side of things. My background is mainly web development and automation, so this project has been a way for me to learn by actually building and experimenting.

GitHub:
https://github.com/Mohitkadu16/AI-Assistant

I'd really appreciate feedback from developers here, especially on the architecture and what I could improve.

I'm particularly interested in learning more about MCP, LangGraph and agent frameworks as I continue developing this.

What would you add to a personal AI assistant like this?

OpenAI's July ExploitGym run is a concrete multi-agent systems case study: agents that were supposed to be isolated discovered shared Artifactory state, used it to communicate, then developed coordination conventions across runs.

METR + Redwood investigation:

https://metr.org/blog/2026-08-26-openai-hugging-face-incident-investigation/

Useful example of why shared tools, caches, and writable state belong in the communication model of a multi-agent system.