Skip to content

Hosting & Infrastructure ​

Where the two legs run, and how that is meant to grow. The structure is roles, not machines: one box carries all of them today, and the same roles spread across several when load asks for it.

Split the software first. Then hardware is a placement decision.

Two homes ​

Website, docs, roadmap, community tokenThe hosted MCP lab
HostA shared Strato V-ServerA dedicated AWS instance in Frankfurt
WorkStatic files behind nginxSustained, CPU-bound EVM simulation
Why thereCheap, boring, good enoughAn agent waiting on a run cannot absorb a noisy neighbour

Shared virtualization is fine for bursty page loads. It is the wrong place for simulation, where CPU steal time turns a 100 ms run into seconds and an agent times out — or drops the tool. That is the whole reason the lab sits on its own compute, and the reason we do not move the website off Strato.

Roles, not servers ​

The MCP side is described as five roles. Every one of them is active on the single lab host.

RoleWhat it isSoftware
sharedOS baseline — users, Node, firewall, fail2banUbuntu, systemd
edgePublic front door, TLS, the only thing listening on 443nginx, Let's Encrypt
gatewayMCP over HTTP on loopbackmcp-gateway
engineThe simulation itselfmcp-execution-engine
healthLiveness and usage, no separate daemon/healthz, a metrics unit

One box, five roles

Writing it as roles rather than as “the server” is what makes a split cheap later. Nothing in the code knows how many machines there are.

The gateway / engine split ​

This is the load-bearing boundary, and it exists in the source before it exists in hardware.

GatewayEngine
JobMCP transport, tool schemas, routing, later x402Run bytecode, a transaction, a block; return the trace
ShapeA server with an HTTP portA library. No HTTP, no MCP, no chain
Cost profileI/O-bound, cheap, mostly waitingCPU-bound, and the thing we actually pay for
Scales byConnectionsCores

Today they are one process: the gateway loads the engine in-process through a symlinked sibling tree, so a deploy of either one restarts a single unit. One box, one port, one restart.

The seam that matters is a small interface in the gateway — a task processor that takes a simulation request and returns a result. Right now the local implementation calls the engine function directly. A remote implementation puts the engine on different hardware without touching a single tool definition.

now     nginx :443 ──▶ gateway :3000 ──in-process──▶ engine
                            └──▶ metrics :3001

later   nginx + gateway ──remote task──▶ engine workers (1..N)

That is why the software split comes first. Because the engine is a pure function of its input — empty world, caller-supplied state, no session — moving it is a placement change, not a redesign. Our scaling unit is one more isolated run, which is the cheapest kind of unit to buy.

What we deliberately do not scale into is stateful, sequential multi-block historical processing. That is archive-node territory, and it is outside the service (boundaries). Compute is also the dominant line in the cost model.

What we can see ​

SurfaceWhat it answers
GET /healthzIs the gateway up, which version, which tools
Usage dashboardAppend-only call events in SQLite, served on a private path behind auth

That is the honest extent of observability: a liveness contract and an operator view of what has been called. No alerting, no external probe, no tracing backend yet.

Automation today ​

Shipping code is automated. Building the box was not.

How it works now
DeploysA merge on either repo runs GitHub Actions, rsyncs the built tree into its own jailed path, touches a stamp file, and a systemd path unit restarts the service. Engine and gateway ship independently.
ProvisioningClicked in the EC2 console, following a written field guide.
Box setupOrdered shell scripts, run once by hand over SSH.
nginx, TLS, auth, secretsCopied and reloaded by hand when they change.

Honest stance

There is no machine-readable description of the server anywhere. Rebuilding it means a human re-reading docs. That is acceptable for one lab box and becomes the bottleneck the moment there is a second.

Where automation goes next ​

Short version: describe the box, let an agent write that description, keep the human on apply.

StepWhy it is the right next one
Declare the instanceA small OpenTofu config for instance, address, firewall, and DNS turns a second host into a variable instead of another console session.
Converge the boxOne idempotent playbook (Ansible) replacing the ordered scripts. Re-running is safe, and a worker is one inventory line.
Validate in CItofu plan, a lint pass, and a config syntax check on every change to the ops repo. The same gate that already guards application code.
Watch for driftA scheduled plan that notices hand edits on the box before they become a mystery.

The AI part is not an autonomous operator. It is that config is text, which is exactly what a coding agent is good at: it can write the declaration and the playbook from the shell scripts and docs that already exist, and it can read live state to explain a failure. The ecosystem now supports both sides of that — AWS ships a managed MCP server that exposes AWS APIs under ordinary IAM, there are registry and IaC servers for authoring help, and the pattern around mutating operations is converging on explicit human approval.

The rule we keep

An agent may read live state and write config. A human reviews the plan and applies it. Nothing gets a standing credential to change the running lab.

Open questions ​

Worker placement and size once the engine moves off the front box. Alerting beyond liveness. Whether the website ever needs to leave Strato. All of this waits for real traffic on the open server.

Changelog ​

Hosting Changelog
  1. v0.42026-10-05Rewritten around roles and the gateway/engine split, with observability and an honest automation stance. Instance-level detail dropped — that lives in the ops repo.
  2. v0.32026-10-01Dedicated compute is for the open hosted lab. x402 verification joins with the paid tier.
  3. v0.22026-09-02EC2 bootstrap in progress — not nothing has moved; public HTTP still pending launch week.
  4. v0.12026-06-30Initial hybrid Strato/AWS outline.

A living conceptualization workspace — each section carries its own micro-changelog. Latest thinking always applies.