Tencent EdgeOne Makers - Ship AI agents like web apps, in minutes.

@sandy_liusy 
Weekend shippers are exactly who we built this for 🙌 Throw an agent at it and let me know how it goes — genuinely want to hear what works and what doesn't. Happy to help if you hit anything!

@sandy_liusy Thanks! ❤️ That's exactly who we built Makers for.

Getting an agent demo running is easy these days. Getting it production-ready is where most weekend projects slow down. We wanted to make deployment, memory, sandboxed tools, and scaling feel as simple as shipping a web app.

Would love to see what you end up building—feel free to share it with us when you launch! 🚀

@sandy_liusy Weekend builders are exactly who we made this for. Spin one up and let us know what you ship — edgeone makers dev, then deploy. Have fun, and thanks! 🙌

@ea_z "Push and it runs" was the whole goal — glad it comes through. Shipping shouldn't be the painful part. Thanks for the upvote!

Appreciate it! We believe developers should spend time building great agents, not stitching together infrastructure. "Push and it runs" is the experience we're aiming for.

@shaowei1 Love this — that "blank repo paralysis" is real. Starting from something that already runs means you're editing toward your idea instead of scaffolding from zero. That's exactly the bet. What are you thinking of building?

Totally agree. Sometimes the hardest part is just getting that first version out the door.

@danielwayne Thank you! Really appreciate the support 🙏

@tobias_lau  @danielwayne Thanks! Let us know what you think if you could take some time to try our product.

@shubham4real Good distinction — cache-centric delivery is tuned for human browsing, not agents.

The key point: agent/API traffic doesn't go through the caching path at all. Cacheable content is served the conventional way at the edge; dynamic and agent work runs on a separate compute layer (Edge Functions for short calls, a dedicated Agent runtime for the stateful ones). That path auto-scales with bursts instead of leaning on cache hit-rates, and agent sessions are sticky-routed so warm state is reused across steps rather than re-established each call.

So it's not "cache the uncacheable" — it's edge for distribution + a runtime built for the dynamic side. Curious what traffic patterns you're seeing?

Really interesting point. One thing we've noticed is that agent traffic is starting to look very different from traditional web traffic, which makes these infrastructure questions much more interesting than they used to be. Curious what kind of agent workloads you're seeing.

@shubham4real Good point — agent traffic really doesn't look like human browsing, so CDN caching alone wouldn't cut it. Makers runs as a separate hosting/runtime layer built around executing requests rather than caching pages. Web delivery's still there for what it's good at, agents are handled separately. What's your workload like? Can pull in the team if you want to go deeper.

Thanks! The AI ecosystem is moving so quickly that flexibility feels more important than ever. We wanted people to be able to choose the models and frameworks that make sense for them.

@jody_l_wyatt Exactly — that's why it's framework-agnostic (Claude / OpenAI / LangGraph / CrewAI) and the model gateway is OpenAI-compatible, so swapping models is a config change, not a rewrite. Bring your stack, don't bet the house on one. Thanks! 🙏

@jody_l_wyatt Totally — and once you're locked in, switching costs just keep compounding. That's why we designed it so you pick the framework and model, not us. Your stack stays yours. Thanks for the kind words!

@blink_66 Thanks! That's exactly the transition we kept seeing — getting a demo working is one thing, turning it into something real people can rely on is another.

@blink_66 That experiment-to-production gap is exactly the gap we're going after — the memory, tracing, scaling and storage you suddenly need in prod are built in, so the jump is a deploy, not a re-architecture. Thanks! 🙏

@blink_66 That transition pain is exactly what got us started on this — going from "it works in my notebook" to "it works for real users" should be a push, not a project. Glad it resonates, thanks!

@andy2026 Appreciate that😊We've definitely felt that pain ourselves, which is a big part of why Makers exists in the first place.

We’ve used a lot of setups where everything is split across multiple services, and it usually adds up quickly in terms of things to manage and keep in sync.

@andy2026 Thanks! That was deliberate — Web and agents share the same project, deploy, domain and env, so your frontend and your agent backend aren't two systems to keep in sync. One repo, one deploy, fewer moving parts.

@andy2026 Yes, this is one of our architectural decisions.

Our view is that an Agent is fundamentally just another "route" within a web application, so there's little reason to split it into a separate project. As a result, within the same project you can have:

/app → Your web frontend (static pages / SSR)

/agents/customer-service → Agent endpoint

/cloud-functions/api → Supporting APIs

Everything lives in a single codebase and is deployed together, making it easier to develop, manage, and evolve the entire application stack.

@andy2026 hanks! Yeah, splitting them into two separate worlds — two repos, two deploys, glue code in between — never made much sense to us. Keeping them in one project just means less to babysit. Glad it landed for you.

@shaowei1 That’s very real☺️ The gap between “it works” and “it runs reliably in production” is still where most of the time goes.

@shaowei1 So true — that "make it production-ready" phase is the part everyone underestimates. The idea here is the platform absorbs most of it (memory, tracing, scaling, storage built in), so that 3x doesn't land on you. Thanks for the kind words! 🙏

@shaowei1 Ha, the 3x underbudget thing is painfully accurate — everyone's been there. That's basically the gap we're trying to close: you shouldn't have to budget for production-readiness as a separate project on top of the agent itself. Appreciate you putting it so bluntly!

@luki_notlowkey Really good question, and honestly the thing we worry about most. Our rule of thumb: a new builder should be able to ignore 90% of the platform and still ship something. New capabilities go in as opt-in depth, not things you're forced to learn on day one — start from a template, get something live, then reach for the advanced pieces only when you actually need them. The day "more powerful" starts meaning "harder to start" is the day we've gotten it wrong. Appreciate you pushing on this one.

@luki_notlowkey The real test for us isn't how much we add, it's whether the experience stays intuitive as we grow. New capabilities go underneath, never crowding the first screen — so the path in stays just as short whether we ship 5 features or 50. Getting started should feel the same on day one no matter how much depth we add. That's the line we won't cross.