# Two servers, two jobs

URL: https://kywi-docs-production.up.railway.app/agent/two-servers-two-jobs
Type: docPage

The site server reads and writes one site’s content over its API; the developer server edits `kywi.config.ts` or scaffolds through that same API.

Kywi ships two MCP servers, and which one is running decides what an agent can do — not a mode flag on a single server, but two separate binaries with two tool sets that meet in exactly three names.

## The site server: one site, its content

Everything the site server registers — content, layout, feeds, components, menus, search, media, users — goes over that one site's REST API. It never opens `kywi.config.ts`; there's no local file path in its configuration for it to open. Everything it does, it does as whatever role the API key in its config carries.

Its content tools are generic and take the type as an argument: `create_content`, `list_content`, `update_content`. The source also carries a function that would register a `create_<type>`/`list_<type>` pair per declared content type — `create_blogPost`, `list_blogPost` — but the shipped binary never calls it, so those tools do not exist in the list your agent sees. Don't write a prompt that waits for one.

## resolve_ref is a site-server tool

The reference an editor copies with **Copy reference** is resolved by `resolve_ref`, which only the site server registers. An agent connected to the developer server alone can't look one up. See [Hand a module to your agent](/agent/hand-a-module-to-your-agent/).

## The developer server: config and scaffolding

The developer server can point at a local `kywi.config.ts`, work purely through the REST API, or have both configured — which one it lands on for a given connection is its own page ([The developer server's mode decides your tool list](/agent/the-developer-servers-mode-decides-your-tool-list/)).

## Two of the three shared names are safe

`get_building_patterns` and `list_module_types` are registered on both and behave identically on both — an agent driving either server gets the same building-patterns guide and the same live module catalog. See [What the agent already knows](/agent/what-the-agent-already-knows/). The third shared name is the one to watch.

## Which server you are talking to decides what “add a module” means

Both servers register a tool called `add_module`, and they do unrelated things. On the site server it places a module into one column of one page's layout — it wants a content type, a content ID, a region, a row and a column, and the page changes. On the developer server it appends a custom-module *definition* to the `modules` array in `kywi.config.ts` — a name, a label and a component path — which is step one of three towards a module that renders, and puts nothing on any page. With both servers wired into one client, an agent that reaches for the wrong `add_module` edits your config when you asked for a section, or the other way round. Name the two entries so the difference is visible in the tool list.

## Wiring both at once

Nothing stops both from being configured in the same client — they're separate entries, started as separate processes, and an agent mid-build reaches for whichever one the task needs: content and layout changes go to the site server, a new content type or a module registration goes to the developer server.

## .mcp.json

Reaching a site at all — the site server's own config shape — is covered in [Point an agent at a Kywi site](/agent/point-an-agent-at-a-kywi-site/); an API key's own limits, which apply to whichever server is using it, are covered in [API keys: scopes are a role ceiling](/agent/api-keys-scopes-are-a-role-ceiling/).
