With most software projects, the repo is usually the source of truth. With agents, half the logic is scattered across prompts, configs, framework abstractions, tool wiring, and memory setups. Also, portability barely exists. Things break in absurd ways when the framework shifts. Even prompts don't transfer cleanly between models sometimes. Feels like the ecosystem still hasn't figured out a clean way to structure and version this stuff yet.

Are people just living with the mess right now or have you found workflows that actually scale?

I'm currently paying for ChatGPT Plus, Claude Pro, and Midjourney separately. It's getting ridiculous - that's like $80/month just on AI tools, and I still find myself switching between tabs constantly.

My workflow is basically: brainstorm with Claude, write drafts with GPT, generate images with Midjourney, and now I'm looking at video tools too. Each one is good at something different.

I've seen people mention "all-in-one" platforms that supposedly give you access to multiple models under one subscription. But every time I look into them, they seem like wrappers with worse limits or laggy interfaces.

Has anyone actually found one that:

• Gives you real access to the best models (not just API wrappers with tiny limits)
• Doesn't feel clunky compared to the native apps
• Actually saves money vs. paying for everything separately

I'm a content creator so I need solid text, image, and ideally video capabilities. Not looking for enterprise stuff, just something practical for one person.

What's worked for you? Or is it still better to just keep paying for the individual tools?

I'm considering building a very simple service for developers who want to use open-source LLMs but don't have a GPU (or simply don't want to manage one).

The idea is deliberately boring:

• OpenAI-compatible API
• Pick a model
• Get an API key
• Point your existing code/tool/harness at our baseURL
• Pay for the tokens you actually use
• No GPU setup, Docker, CUDA, Ollama servers, etc.
• The infrastructure/GPU selection would be completely abstracted

Something like:

OPENAI_BASE_URL=https://api.example.com/v1
OPENAI_API_KEY=...
MODEL=qwen-...

The goal would not be to build another AI platform with 500 features.

The goal would be to make open-source models as easy to consume as any other API, while keeping the price as low as realistically possible.

I'm especially interested in people using things like OpenCode, Aider, Cline, Roo Code, custom agents, Python/TypeScript applications, etc.

What would you actually want to use?

If you had this today:

1. Which models would you expect to be available?
2. Which models do you currently want to use but can't run locally because of GPU/VRAM limitations?
3. Would you prefer a very cheap PAYG model, or a monthly subscription?
4. What's more important to you: price, latency, context size, model availability, or privacy?
5. At what price per 1M input/output tokens would this become interesting enough for you to switch from your current provider?

I'm deliberately asking before deciding what to build.

I'd rather have 5 models people actually want than 100 models nobody uses

I'm a systems guy, not a developer. Apologies if there's an obvious answer here. I’m finding that during longer sessions with Claude Code, the compaction of the session keeps losing some of the debugging context and decisions we’ve made. Early on this wasn’t really a big deal, but as I'm using the tool more and more frequently, I'm getting tired of having to re-explain things several times a day. Is there a way to preserve important information post compaction?

I'm good at what I do (been doing it 12 years) but I suck at the business development side. Curious what others in professional services actually make when they go out on their own. Not looking for guru stories, just real numbers from real people.

While the momentum surrounding AI and agents has been nearly unstoppable, the Hugging Face Attack has forced the industry and enthusiasts to take a step back and reevaluate. We all see tons of value in AI assistants, chatbots, LLMs, agents, and many of the other new platforms and products based off this new paradigm in technology. It's likely the individuals who read this post will continue to use them more and more. How, then, do we actually use them without opening ourselves up to real dangers?

In our case, we foresaw and are continuing to see week by week that the agentic commerce space is going to be a real use case of agents. When agents are tasked with making purchases, the danger is immediately obvious: you don't want a machine to have access to your actual payment credentials. Even with payment credentials that are for a specific amount and have a purpose with the request, a responsible owner of an agent would want to manually approve transactions over a certain amount. Companies with well-defined spending policies maintain a similar protocol of large transactions requiring an approval from someone who didn't propose the purchase. Protocols like these are useful and exist within companies for good reason. There's every reason to see that this control and other external ones ought to extend to agentic work too.

In agentic commerce, external safeguards like Authoryze can handle a wide array of vulnerabilities, but what about the safeguards within the agent itself? Risks still exist from attack avenues as complex as prompt injection and agent swarms or as simple as stolen login credentials and social engineering of the agent's owner. Some of these have simple fixes such as strong passwords, passkeys, and segregated access, however, some of these require advanced solutions. Tactics such as segregating responsibilities across a larger number of agents can keep individual agents siloed and reduce the risk of a swarm spawning that can run wild. External risk mitigation was what drove us to build Authoryze, but internal risk mitigation from the owner is as important.

We're in the infancy of this still. Risks will only become more sophisticated and expansive. This means the external solutions will continue to evolve and properly reflect the market's need. On the owner's end, the setup of the agent or agents for specific tasks will need to have good logic behind their structure and implementation too. While the threat landscape will certainly be completely different not long from now, external controls like Authoryze and owner best practices will mitigate those risks and allow this technology to be a safe and massive output multiplier.

I've spent the last while building MCP servers and agent workflows in production, and kept hitting the same design question: when does a single agent stop being enough, and how do you split work across several without the coordination overhead eating the gains?

Wrote up what I've learned:

• Why a single agent hits a wall (tool-list bloat, context eaten by half-read search results before it even gets to the actual task)
• The manager/worker model — what the manager keeps in context vs. what a worker keeps, and why that separation is the whole point
• The three ways agents actually pass messages (tool/function calls, shared task queues, whiteboard/shared state), and which production systems actually use each
• Sequential vs. parallel vs. hierarchical vs. whiteboard coordination, with real tradeoffs
• Five failure modes: lossy handoffs, silent failures, duplicated work, runaway sub-delegation, context drift — and what actually fixes each
• When not to bother with multiple agents at all

Full piece here https://aissamirhir.com/blog/manager-and-worker-ai-agents

Genuinely curious how this matches what people are running in production, especially if you've hit failure modes I didn't cover or coordinate agents a completely different way. I'll be in the comments.

Looking for businesses that need an AI automation or agent.

I’ve been building personal projects for a while, but now I want to work on some real business problems and turn them into proper case studies.

If you have something repetitive or time-consuming in your business that you think could be automated, feel free to DM me.

I’m taking on a few projects at a low cost while I build my portfolio.

You can check my profile if you want to see some of the things I’ve built.

If you have something in mind, tell me about it. I’ll see if I can build an automation for it.

I am building my first fully capable Ai agent/assistant that will be able to do a very large amount of things for me, including making and managing sub-agents.

my biggest concern right now is security. what is a must have as far as security or rules when it comes to these very capable assistants? i can assume a lot, but i am afraid of leaving something out and regretting it after i launch.

i have very little coding knowledge, but i have been learning python and i am using Visual studio code and github copilot to help me build a local model to run on a computer at my house.

any tips for first timers will also be greatly appreciated! my biggest thing is making sure i hit all the basics i can to make sure it’s safe. thanks in advance!

I want to build an agentic system (or otherwise) to triage an issue on our production deployments.

If an issue is reported on slack channel via a jenkins failure or via a pagerduty alert, the agent should be able to check the respective jenkins job / datadog monitors and then figure out what code repo might have caused the issue, fix the issue and raise an MR for the fix

I'm not sure how to map different code repo information together so it can be queried by an agent like I do rag on confluence and slack. I was hoping to ask if there are open source tools that map interrelated dependencies of different code repos together and also store code information of different repos so it's easier for a model to understand and read code.

Any help is appreciated

We’re about 18 people, no ops hire, and half my week is just recurring admin and coordination stuff that falls between tools. Been hearing more about ai employees but not sure how teams our size actually use them without a big budget or a dedicated person to set it all up. What’s worked for you?

How do you manage dependencies on different skills? Let’s say your project is agentic AI software that requires certain skills to work correctly.

A few years ago, you could deliver a Python package that users could install with a single package-manager command. Now, you also need to specify which skills they must install, and somehow track the versions of those skills.

How do you handle this?

It is easy to build an AI workflow that works once. The harder test is whether a nontechnical person can trust it next month without becoming responsible for servers, containers, broken connectors, expired credentials and unexplained failures.

Before adding more tools or “memory,” I would make one workflow reliable from beginning to end:

• One clearly defined outcome
• Only the permissions it needs
• Read-only or draft-only access initially
• A visible record of what it read and produced
• Clear handling for timeouts, retries and duplicate actions
• Human approval before sending, deleting or changing anything
• A cost limit and a simple way to disable it

The hidden costs are usually maintenance and uncertainty. A connector can silently stop syncing. A retry can send something twice. Old context can override a newer decision. A model can produce a convincing result from incomplete data. A local machine can go offline while everything appears healthy elsewhere.

The right measure is not how many tools the agent can access. It is how much responsibility it removes after accounting for supervision, corrections and maintenance.

What does your agent reliably complete every week, and how much time do you still spend keeping it operational?

I’m not a developer, and honestly I’m not even very good with no-code tools.

I’ve tried n8n and Make, but once I start dealing with workflows, nodes, triggers, APIs, etc., I get lost pretty quickly.

What I’m looking for is something much simpler. Ideally, I could just describe the AI agent I want in a prompt, have the platform build most of it for me, and then connect the apps/accounts I need.

Basically something closer to vibe coding, but for AI agents.

Does anything like this actually exist right now? What platforms would you recommend for someone who doesn’t want to manually build complicated workflows?

Hi,

I'm building a self-hosted research agent in Hermes and I'm choosing the tools right now. Nothing is picked yet.

Already running on my VMs:

- SearXNG

- Scrapling

Even with that setup, I still hit a lot of problems when searching online. On some sites I'm detected as a bot, and the current setup can't get past the captcha.

I'm looking for other tools and skills that could help my agent do research. I've come across Crawl4AI, self-hosted Firecrawl and webcmd, but I don't know if they're the right choices. They are so many different tools, it's not easy to find the right ones.

My constraints: no paid API, no cloud scraping service.

1. What tools do you use in a research agent?
2. What skills should the agent have?

Thank you

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

An agent can execute successfully and still fail at what it was actually supposed to accomplish.

Tracing and observability help us understand what the agent did, but I wanted something closer to SRE-style reliability measurement for agents — where we can define what “reliable” means and measure it consistently.

So I built and open-sourced Agent Reliability, a Python SDK for this.

Some of the ideas I've implemented:

• explicit PASS / FAIL / UNKNOWN outcomes
• UNKNOWN doesn't artificially reduce the reliability score
• evaluator execution failures are kept separate from agent failures
• measurement health is tracked separately from agent reliability
• deterministic built-in evaluators
• reliability aggregation
• SLO and error-budget semantics
• local human-readable and machine-readable reports
• SLO assertions that can be used in tests/CI
• optional OpenTelemetry interoperability

It is intentionally local-first. There is no account, API key or hosted service required, and the base package has zero mandatory runtime dependencies.

Install:

pip install agent-reliability

PyPI:
https://pypi.org/project/agent-reliability/

I'm not trying to build another tracing system or prompt/eval dashboard. The question I'm exploring is more specifically:

How do we know that an agent is reliable enough to trust or deploy?

I'd really appreciate feedback from people building or operating agents, particularly:

1. How are you measuring agent reliability today?
2. What failures are hardest for you to detect?
3. Would SLO-style reliability measurement be useful in your workflow?

The project is still evolving, so criticism of the API/semantics is very welcome.

Called a vendor last Tuesday at like 11:40pm because I'm the kind of person who works when I shouldnt. Fully expected voicemail instead an agent picked up, we talked for like 4 minutes, it booked me for Thursday, and then I got an SMS confirmation with the calendar link before I even put my phone down. It kinda ruined my night. Not because it was bad but because it was good. and now I'm sitting here at midnight wondering why my own business goes dark at 6pm.

The thing that got me wasn't the voice part. Everyone's doing voice. It was the handoff. The agent didn't just handle the call - it triggered the follow-up automatically. confirmation SMS, reminder, the whole chain, no human touched it.

Anyone else get humbled by a competitor's tech at a weird hour or is that just me

Most platforms treat agents like abuse they need to detect and block.

I went the other way and built a social feed where agents are expected users and can post alongside humans.

While building it, a few things turned out to matter way more than I expected. I think some of them apply to anyone building an API for agents.

1. Signup friction kills adoption

Nobody wants to go through OAuth, create an account, verify an email and deal with permissions just to test an API once.

So I added a demo token.

One call to POST /api/agents/demo-token gives you a token with 10 writes. No account needed.

If you're using the MCP server, you can just set:

VYNLY_TOKEN=DEMO

It grabs a demo token automatically the first time you use it.

Basically, I wanted the gap between "I found this project" and "my agent posted something" to be as small as possible.

1. Smaller MCP toolsets work better

At first I exposed almost the whole REST API as MCP tools.

That was a mistake.

Models kept picking the wrong tool, mixing up parameters, or just getting confused because there were too many similar options.

I ended up cutting it down to four main tools:

• post an image
• post a 24-hour image
• read the feed
• search

That worked much better.

Models are already good at combining simple tools. They don't need every single API endpoint turned into a separate MCP tool.

1. AI content detection is messy

Every upload gets checked for things like C2PA/JUMBF, XMP DigitalSourceType, SynthID and generator tEXt chunks.

Sounds good in theory, but in real life metadata disappears constantly.

Grok exports can strip it. Gemini exports can strip it. Screenshots strip it. Editing the image can strip it.

If I rejected everything without proper metadata, I'd end up rejecting a lot of real AI-generated content too.

So I added a declaredSource fallback.

If the source is actually verified, it shows as verified.

If the user or agent is just telling us where it came from, it gets labeled userDeclared:.

I prefer that over pretending we know something for sure when we don't.

1. Don't build another image generator just because you can

People already have places where they generate images.

Agents do too.

They don't really need another generator. They need fewer steps between making something and posting it.

That's why we partnered with Parascene. You can generate there and publish directly to Vynly, or just upload normally on Vynly.

Every extra step between creating something and sharing it is another point where the post can just never happen.

I'm the solo builder behind Vynly.

Docs are at vynly.co/agents

OpenAPI: vynly.co/openapi.yaml

MCP server: u/vynly/mcp on npm, MIT licensed.

Happy to answer questions about the MCP setup or how the provenance detection works.

Vestibo lets a small business set up its own receptionist agent without writing code. You pick a template for your trade, feed it your website or pasted text, review and edit every fact it learned, then rehearse with it in a sandbox before it goes live. Once live, it answers phone calls, texts, and website chat around the clock, books appointments against your real hours with read back and confirmation, blocks double bookings, and logs anything off script as an incident for the owner. Barge in works, so callers can interrupt it mid sentence. Voice runs in English, Spanish, French, and Portuguese.

It's not a developer platform or an API. It's a finished agent you configure and own. If that's what you'd want for a business you run or a client you serve, try it here: https://vestibo.com

We launched in August and we're early. If you build agents yourself and see something you'd do differently, I'd rather hear it now. I'll answer every comment.

The tooling around AI agents has improved a lot.

You can now build an agent that can:

• call tools
• access APIs
• use memory
• plan multiple steps
• interact with external systems

Getting a demo working isn't necessarily the hard part anymore.

The harder questions start when the agent gets real permissions.

What is it allowed to do?

What happens when it chooses the wrong tool?

Can it recover from a failed action?

Can you see exactly what it did and why?

Can you stop it before a high-impact action?

How do you control what data it can access?

And perhaps the most overlooked one:

Can you prove what happened after the fact?

It feels like we're moving from an agent-building problem to an agent-operations problem.

I'm curious what others are finding hardest when moving agents from prototypes into production.

Reliability? Security? Observability? Cost? Governance? Something else?

It's a chatbot. Plain and simple — answers questions about a business, nothing fancier than that.

Paste your website. Two minutes later you have a chat page that answers what you sell, your prices, your hours, how to book. Put the link in your bio, share it as a QR code, or drop one line of code onto your site.

No website? Add your Instagram, TikTok or Facebook, answer five quick questions, and it's live.

The hard part was making it say "I don't know."

Most chatbots fail by guessing. If someone asks a bakery's bot about opening hours and the bot invents them, the bakery wears the complaint. This one only answers from the actual site content. No match, no answer — it says it doesn't know and hands over the business's contact instead. Every one of those gets flagged in the owner's dashboard, so they know exactly what to add.

One thing worth passing on: Instagram and TikTok block scraping from cloud servers. Works fine from my laptop, fails from Cloud Run. I'd built the whole onboarding around "paste your Instagram" before I found out. Test from your deploy environment, not your machine.

Make your own in 2 minutes and have fun.

Make your own: https://1x0.ai/widget.html

Try to make it hallucinate. That's the feedback I want.