u/Consistent-Stock9034

▲ 1 r/nocode+1 crossposts

Duct-taping n8n, frontend builders, and custom APIs together is exhausting. I built a cloud execution layer where an AI agent just builds and runs the custom software for you instead.

Building complex apps without code right now usually means managing a nightmare stack. You use one tool for the frontend, n8n for the logic, another for the database, and custom cloud functions to glue it all together.

When one API breaks, the whole house of cards falls down.

I got tired of managing fragmented workflows, so I built Fleeks.

Fleeks isn't another visual node builder. It’s a cloud execution workspace. You get an AI agent that actually writes, runs, and deploys real custom software in one isolated environment.

In the raw video attached, you can see how it works under the hood:

  1. You describe what you want the app or backend to do.
  2. We instantly spin up an isolated cloud computer. The agent writes the code, runs the server, and tests the output.
  3. If it crashes, the agent reads the terminal logs and fixes the bug autonomously.

The Superpower: We integrated 270+ MCP tools into the platform out of the box. Instead of you dragging nodes around in n8n to connect APIs, the agent natively talks to your external data and services to build the workflow for you.

Instead of chaining together five different no-code tools, the agent builds you a custom backend and deploys it.

We are already open and live in Beta. I’ve included enough free tokens for you to take those messy, unfinished projects you've been duct-taping together and deploy them in the cloud to see if they actually hold up.

Try it here: fleeks.ai

I’m looking for honest feedback on the workflow—give it a spin and tell me exactly where the agent succeeds or where the infrastructure needs more work.

u/Consistent-Stock9034 — 5 days ago

We weren't trying to build an infrastructure product. We were trying to build agents that actually worked in production and kept getting blocked by the same thing.

The agent logic was never the problem. The problem was everything around it. Keeping it alive. Giving it persistent access to the right tools without writing a custom integration for each one. Making sure that when it ran at 3am and something went wrong, it didn't just silently die and leave the system in a broken state.

We went through every combination of Docker containers, Lambda functions, managed services. Everything was either too fragile, too expensive to maintain, or required more engineering than the actual product we were trying to ship.

Eventually we stopped trying to bolt existing tools together and built the layer that was missing. That became fleeks. You build your agent locally, run fleeks promote, and it runs 24/7 on persistent infrastructure with native connections to AWS, GitHub, Postgres and the rest of your stack. No glue code, no servers to manage.

But I'm more curious about how others are tackling this because I suspect everyone has a different version of the same war story.

Are you self-hosting? Using a managed platform? Just keeping a VPS alive and hoping it doesn't crash? And if you've built something that actually works well, what made the difference?

Would genuinely love to compare approaches here. This feels like a problem the community hasn't fully solved yet and there's probably a better answer somewhere in this thread.

reddit.com
u/Consistent-Stock9034 — 15 days ago
▲ 17 r/ShowMeYourSaaS+11 crossposts

Building an AI agent is the easy part now. Anyone can do it in an afternoon. But the moment you want it running permanently in the background, actually connected to your stack, doing real work while you sleep, that's where everything falls apart. You end up spending more time on the microservice hosting the agent than on the agent itself. The logic takes a day. The plumbing takes a week and then breaks on a Tuesday for no reason.

I kept hitting that same wall. Eventually I stopped complaining about it and started building https://fleeks.ai/.

You build your agent locally, test it, make sure it behaves the way you want. Then you run fleeks promote. It goes live on Fleeks infrastructure and runs 24/7. No server to spin up, no containers to manage, no babysitting.

The other thing that makes this different is native MCP support, which means your agents connect to AWS, Kubernetes, GitHub, Postgres, PagerDuty without you writing a single integration. The agent figures out the API calls itself based on what you tell it to do.

We use it internally for autonomous incident response. A deployment fails, the agent catches it, traces the root cause, patches the config, and opens a PR before anyone gets paged. That loop runs without us.

Fleeks is fully open-source. You can audit everything it does locally before you promote anything to the cloud, and you can run the whole engine inside your own VPC if you need full control.

Would love feedback from anyone who's tried to solve this hosting problem themselves. What did your setup look like before?

u/Consistent-Stock9034 — 6 days ago
▲ 4 r/indie_startups+1 crossposts

Building used to feel like this:

Have idea. Open editor. Wait for dependencies to install. Hit an error. Fix it. Wait again. Get it running. Try to test something. Wait for a build. Change one line. Wait for another build. Want to deploy it? Now you're on YouTube learning Docker at midnight.

You spend more time waiting and configuring than actually building the thing.

I got fed up and built Fleeks.

Here's what it actually does: you describe what you want to build in your terminal. It figures out the stack, loads the right languages and dependencies, and gets your local environment ready. You write the code, or you let your AI agent do it, and Fleeks handles the dev servers and testing in the background. When you're ready to ship, one command containerizes the whole thing and pushes it to managed cloud infrastructure. You get a live URL or an always-on webhook for your agents. That's it.

We've been running it with a few teams already. The part that surprised me most wasn't the deployment speed. It was how much cleaner the whole build loop felt when infrastructure wasn't the bottleneck. You actually stay in the problem instead of context-switching into DevOps mode every 20 minutes.

Still early, still rough around some edges. But it works.

If you've got something unfinished sitting around, bring your coding agent and test it. Free to start. Link in the comments.

If you get stuck, DM me directly.

reddit.com
u/Consistent-Stock9034 — 17 days ago