I Built My Own DeepSite Alternative That Works with Kimi K2.5, Gemini, or Any Model

Source: Dev.to

I got tired of DeepSite.
Don’t get me wrong, it’s a fun tool. Type a prompt, get a website. But every time I used it I kept running into the same problems:

• You can’t pick the model.
• You can’t self‑host it.
• There’s no quality check on what it generates – you just get whatever comes out and deal with it.

I wanted something where I could plug in whatever model I felt like using that day.
Kimi K2.5 just dropped? Let me try it.
Gemini got an update? Switch it.
Claude writing better code this week? Cool, use that instead.

So I built AgentSite – open source, self‑hosted, and instead of one model doing everything it uses four AI agents working together like an actual team.

A Quick Demo

I just built a travel‑agency website using Kimi K2.5 and the whole thing took one prompt.

Four Agents, Not One

When you hit Generate, AgentSite splits the work:

Your prompt → PM → Designer → Developer ↔ Reviewer → Done

• PM – plans the site structure.
• Designer – creates a colour palette and typography system.
• Developer – writes the actual HTML/CSS/JS.
• Reviewer – scores accessibility, code quality, and visual consistency. If the score is below 7/10, the Developer gets feedback and fixes it (up to two revision rounds).

That reviewer step is the part I haven’t seen anywhere else.

Getting It Running

Deploy with Railway

The fastest way is straight from GitHub. The README contains a Deploy on Railway button – click it and Railway handles everything (no terminal, no local installs).

Run Locally

pip install agentsite
agentsite serve

You can also run the Docker image if you prefer.

Setting It Up

1. Add an API key – go to Settings → Providers and paste your key (Moonshot AI, OpenAI, Google, Anthropic, etc.). You can add multiple providers and mix them across projects.
2. Choose a model – go to Agents and set the default model for each agent. I set all four agents to moonshot/kimi-k2.5, but you could use Kimi for coding and Claude for reviewing, for example.

New model drops tomorrow? Change the dropdown, done.

Building Ukelele Travels

I created a project called Ukelele Travels, a travel agency that sends people to Venezuela.

Inside the project you get a detail page where you manage all pages, see the brand identity, and get an overview of what’s been generated.

I created a home page, typed my prompt, and let the four agents do their thing. Here’s the page builder after generation – chat on the left, live preview on the right.

All of this from one prompt. Kimi K2.5 runs through four agents:

• PM – planned the structure.
• Designer – picked colours and typography.
• Developer – wrote clean HTML, CSS, and JS.
• Reviewer – checked it and sent feedback until it passed.

No templates, no frameworks – just pure code.

Tracking Everything

The Analytics page shows token usage, cost breakdown, and a step‑by‑step log of each generation.

When you’re paying for API calls, it’s nice to know where the tokens are going. The Reviewer agent uses far fewer tokens than the Developer, which makes sense because it’s reading and scoring rather than writing full pages of code.

Why This Approach Is Better

When you ask one model to do everything, you get a compromise:

• Planning is only “okay”.
• Design is generic.
• Code works but can be messy.
• Nobody checks the output.

By splitting the work across specialized agents, each step gets the attention it deserves, resulting in higher‑quality sites with built‑in review and the flexibility to swap models whenever you like.

Give AgentSite a try – the code is open source, you can self‑host, and you get a true “team” of AI assistants at your fingertips.

Multi‑Agent Workflow

Each agent only needs to excel at its own task:

• Product Manager – no need to write CSS.
• Developer – doesn’t pick colors.
• Reviewer – just reviews.

Because every agent receives the previous agent’s output as context, the whole process stays consistent.

I’ve been running different models through this pipeline for a while now, and the multi‑agent output is consistently better than any single‑prompt approach I’ve tried. Not just a little better—noticeably better.

About Kimi K2.5

Since I used it for this entire demo, here are some quick notes:

• Consistency: Kimi K2.5 is one of the most reliable models I’ve run through AgentSite. Most models stumble in at least one role (e.g., great at coding but produce bland design, good at planning but generate sloppy code).
• All‑round performance: Kimi performed solidly across all four agents.
• Speed: Fast execution matters when you’re chaining four sequential agents plus revision loops.
• Schema fidelity: It never broke the structured JSON schema the agents use to pass data. Some models hallucinate extra keys or mess up nesting; Kimi didn’t.

That said, the whole point of AgentSite is that you’re not married to any single model. I built Ukelele Travels with Kimi K2.5 today; tomorrow I might switch to Gemini or Claude for the next project—just change the dropdown.

Try It Yourself

GitHub:

• One‑click deploy buttons for Railway, Render, and Heroku are included in the README.
• Or install locally:

pip install agentsite

The project is MIT‑licensed and free; you just bring your own API keys.

If you try it out, let me know which model you used and what you built—I’m genuinely curious to see what people create!