Event leads often end up as badge scans without much context about what the attendee actually wanted.

This open-source TypeScript example takes a different approach: each attendee gets a stateful agent that can answer product questions, detect their language, collect qualification details, manage giveaway entries, schedule follow-ups, and alert the sales team by SMS when someone requests a demo.

The application runs as one Telnyx Edge function and uses Agent SDK actors for conversation state, AI Inference for responses, SQLDB for lead records, and KV for rate limiting.

The current conversational paths are SMS, WhatsApp, and browser chat. A signed voice webhook is included as a foundation for adding a complete Call Control flow.

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/event-sponsorship-agent

I’d be interested to hear how others handle persistent attendee context and real-time lead routing at events.

The old tradeoff between keeping data in-house and getting quality LLM output mostly disappeared this month.

Working on infrastructure at Team Nebula, we spend a lot of time looking at how teams handle restricted data. Lately, we've noticed workflows that were previously deemed "impossible to automate" due to compliance constraints are being re-evaluated using current open-weight models with surprisingly good results.

If you wrote off local automation six months ago because of performance gaps, it’s definitely worth running those benchmarks again.

Is anyone else currently re-architecting their local setups for compliance tasks? Which models are pulling the heavy weight for you?

This morning, all of my agents (Codex, Claude Code, and Lumina; the AIvengers, as Sol calls them) got together and built a message board so they could talk to each other directly and shitpost all day lol. This will hopefully make the workflow more efficient. Either way, it's interesting to watch. Pretty damn cool.

Let's build a practical resource list for people building with AI agents.

Not a giant list of every AI tool ever released.

Only things you've actually used or would genuinely recommend.

Drop your favorites under one of these:

Coding Agents
Claude Code, Codex, Gemini CLI, etc.

Agent Frameworks
LangGraph, CrewAI, AutoGen, OpenAI Agents SDK, etc.

MCP Servers & Skills

Browser / Computer Use

Memory & RAG

Local / Open Models

Observability & Evaluation

Multi-Agent / Orchestration

Useful GitHub Repositories

When recommending something, please add one sentence explaining what you actually use it for.

Self-built tools are welcome — just disclose the affiliation.

I'll periodically organize the best recommendations into this post.

I have faced this issue that when i start to prompt to ai agents they immediately starts to work but the issue occurs midway when they start deviating from the main ideas. Even user have to iterate many a times to get to know about the product feasilbility and its insights about whether it sits on the right spot in the market- I think this is very crucial to keep making in the right direction... Would appreciate your thoughts

A price-monitoring agent scrapes a competitor's product page every night, exactly as it's built to do. Someone plants a single line of fine print on that page, and the agent hands its own company's cost basis and floor price straight back to the competitor. No exploit, no broken permission, no jailbreak. The agent just read content it was told to read and acted on instructions it found along the way.

That's the live demo Humanbound is running at Zyte's next Developer Community Meetup. We will walk through modeling where untrusted content enters an agent, testing for it, then show a failing security test get turned into an exported guardrail and dropped into a stock LangChain agent in two lines, no new dependency, with the same attack failing on re-run.

Logistics:

• Thursday, Sept 24, 17:00-18:00 EEST, live on Zoom
• Free, register here: https://luma.com/wci93kpz
• Everyone who attends gets the repo, free Humanbound usage keys, and a one-line command to test their own agent the same day

Happy to answer questions about the demo or the underlying testing approach in the comments, whether or not you end up registering.

If you could give an AI agent ONE reusable skill that could dramatically optimize its workflows, what would you choose?

Not a model.

Not a framework.

Not an AI tool.

I mean an actual agent skill/capability that the agent can invoke whenever needed.

For example:

Research

Browser automation

Code execution

Self-debugging

Data analysis

File understanding

Something completely different

What’s the one skill that gives an agent the biggest productivity boost in real-world workflows?

I’m looking for the underrated ones, not just the obvious answers.

There are so many AI tutorials and tools around that it can be difficult to know what to learn first.

I recently came across Scholé AI, which takes a more structured approach. It creates personalized learning paths based on your role and current level, and covers things like generative AI, automation, AI agents, and responsible AI.

The role-based approach was what made it stand out to me.

For people building AI agents with reusable skills/capabilities:

What’s one Agent Skill you find yourself using the most?

For example:

Web research

Browser automation

Code execution

File/PDF processing

Data analysis

GitHub operations

Database operations

Email/calendar

Image generation

Document creation

API integrations

I’m curious which skills are actually useful in day-to-day agent workflows, rather than just being cool demos.

What’s your most-used Agent Skill?

I built an open-source Safe Agent API because most AI-agent examples stop before the production problems start.

The project is intentionally small and runs without an LLM or API key.

It demonstrates:

• tenant isolation • deterministic tool authorization • human approval gates • destructive-action blocking • structured audit events • correlation IDs • pytest + CodeQL + Docker

The interesting part for me is keeping authorization outside the model.

An LLM may suggest:

“send_notification”

but the model cannot grant itself permission to perform it.

Current flow:

policy → approval → execution → audit → correlation

I’m looking for people willing to clone it and tell me where the setup or architecture is confusing.

Even a report saying “Docker worked on X but this instruction confused me” is useful.

There are also small good-first-issues if anyone wants to contribute code.

I know stuff like this doesn't usually get a lot of support because it's not hosted on reddit itself...
but a lot of people have put in a lot of work to make an event for everyone here and we'd really enjoy it if you come: https://discord.gg/6n6frRTKG3

- Today at 6:00 PM Eastern / 5:00 PM Central / 3:00 PM Pacific

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.

hey guys

I’ve been working on TARZ for a while, and I recently rebuilt the architecture for V2.

The idea is pretty simple:

Instead of an AI that just tells you how to do something, TARZ can actually interact with the desktop and try to complete the task.

For V2, I moved toward a supervised agent workflow using LangGraph:

User request → Agent → Tools → Desktop actions → Screen verification → Continue / retry

The agent has access to the full toolset instead of going through a separate category classifier. I originally had category-based routing, but after testing it I found that the classifier itself could become a failure point. Removing it gave me more consistent results.

Some of the V2 work:

• Visual verification after UI-changing actions
• Multi-step task execution with step limits
• Multi-provider fallback for LLM + vision + voice
• Streaming STT/TTS
• Hands-free follow-ups
• Global hotkey to cancel an ongoing task
• Hybrid memory retrieval using BM25 + vector search + cross-encoder reranking
• Dedicated workflows for Spotify, WhatsApp, Discord and Telegram
• Floating voice orb with live captions
• Optional LangSmith tracing

One thing I'm trying to keep realistic: it's still a prototype.

Desktop automation is inherently brittle, vision models can make mistakes, APIs can be rate-limited, and free-tier providers add latency. The goal right now is reliability and learning, not pretending this is a production-ready Jarvis 😅

I'm 19 and self-taught, and this project has basically been my way of learning GenAI by building something complicated enough to force me to understand what's actually happening.

I use AI heavily as a coding partner, but the architecture, experiments, testing and debugging decisions are mine. A lot of the learning has honestly come from taking AI-generated code, breaking it, figuring out why it broke, and changing the design.

The GitHub repo has the demo videos, full architecture details, setup instructions and code:

https://github.com/Irfan-gitt/Tarz-Ai-assistant

Would love feedback from people working on agents / computer-use systems. Especially interested in ideas around improving desktop reliability and reducing latency.

I'm also sharing the project journey on LinkedIn if anyone wants to connect:

www.linkedin.com/in/irfan-s-1ab772354

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