Tool Box

Tool Box is a C#/.NET 10 implementation of a Model Context Protocol (MCP) server — the open protocol that Claude Desktop, Claude Code, and a growing set of agent frameworks use to call tools. Most MCP servers wrap a single API. This one is built as a platform: a thin Host that knows nothing about any specific capability, a Core library of shared plumbing, and a growing set of independent toolsets that each plug into the Host through exactly one line of composition code.

The LLM is the brain. This project is the hands.

The castle above was built live by an AI agent through the project's Voxel toolset. Every block was placed by a real MCP tool call — place_box, place_cylinder, place_cone, mirror — over the same wire an agent uses, and rendered in the browser as the calls landed. No part of it was hand-placed.

What it demonstrates

Every claim below is backed by something that can be run or read in the repository, not asserted.

Area	Evidence
System architecture under real constraint	The Host/Core/Toolset boundary held through the addition of a second toolset with genuinely different needs — stateful, write-classified, and running its own background service — with zero diffs required in `Core/`. Measured, not claimed, and recorded in the architecture decision log.
Protocol and networking depth	A single binary serves two MCP transports — stdio and streamable HTTP — selected at runtime, alongside a hand-rolled `HttpListener`-based WebSocket server with a correct close handshake. A real bug in that handshake was found and fixed during development rather than shipped.
Testing discipline	77 tests across four projects: pure-logic unit tests, tool-layer functional tests with no server involved, and wire-level integration tests that boot the real HTTP app and drive it with the real MCP client SDK. CI runs all of it plus a container boot-and-healthcheck smoke test on every push.
Engineering judgment, on the record	Every non-trivial decision is a dated, append-only Architecture Decision Record in Michael Nygard's format — eleven so far — including one that revises an earlier security assumption once circumstances changed, with the reasoning written down rather than silently overridden.
Security posture, stated not assumed	The HTTP transport's threat model — isolation versus authentication, and what actually gates exposure — is documented and was re-examined on the record the moment a write-classified toolset made the original assumption stale.
AI-assisted engineering, done deliberately	The project is built through a staged, repeatable process: written design goals, recorded discussion, a reviewed implementation plan, and step-by-step permissioned execution — all logged in full.

Architecture

  MCP client (Claude Desktop / Code / Inspector / LangGraph agent)
        │  stdio  ─or─  streamable HTTP (:8080/mcp, /health)
        ▼
  ToolBox.Host        thin composition root: config → toolsets → transport
        │
  ToolSets/*          independent capability libraries (Basics, Voxel, ...)
        │
  ToolBox.Core        shared plumbing: bounded output, server info, logging rules

The Host is a composition root and nothing more: it wires configuration to toolsets to a transport, and contains no domain logic. Core holds the shared plumbing every toolset relies on — bounded output, structured logging conventions, server metadata. Each toolset is an independent class library that registers itself with a single line. The design rules held across two very different toolsets: toolsets never know about the protocol or about each other, all tool output is bounded, and a stdio server's stdout belongs exclusively to the protocol, so logs always go to stderr — verified on every change, not assumed.

The toolsets

Basics — connectivity and identity tools (ping, server_info, current_time) that proved the platform's plumbing before anything more interesting was built on it.

Voxel — a live, agent-buildable 3D world. Twelve tools (place_box, place_sphere, place_cylinder, place_cone, place_tube, mirror, remove_box, and more) that describe shape rather than coordinates: an agent asks for "a hollow cylinder, radius 3, height 8," and the server rasterizes that into cubes. Every change broadcasts over a WebSocket to a live Three.js browser viewer, independent of whichever MCP transport the agent happens to be connected over. The Voxel toolset brings its own companion infrastructure — a BackgroundService that broadcasts world changes over a loopback WebSocket on :8090, deliberately kept from colliding with the MCP HTTP transport on :8080.

Transports

One binary, two wires, chosen at startup with clear precedence — a --transport flag, then a TOOLBOX_TRANSPORT environment variable, then appsettings.json, defaulting to stdio.

Transport	How it starts	Used for
stdio (default)	the client launches the DLL	Claude Desktop, Claude Code — local, client-as-parent
streamable HTTP	`--transport http`	remote and containerized consumers; serves `/mcp` and `/health` on `:8080`, stateless

The image is built and health-checked in CI, so "the container boots" is a continuously verified claim rather than documentation that quietly drifts from reality. The Dockerfile is multi-stage, non-root, and ordered for layer caching.

Technologies

C# and .NET 10 (current LTS), with warnings treated as fatal via Directory.Build.props
The Model Context Protocol and the official MCP C# SDK
ASP.NET Core for the streamable HTTP transport
A hand-rolled HttpListener-based WebSocket server with a correct close handshake
Three.js for the live browser viewer
Docker and Docker Compose, with a CI healthcheck smoke test
GitHub Actions for continuous integration across four test projects

Why it matters

Tool Box is a working answer to two questions a hiring team actually cares about. First, can this person hold a clean architecture under pressure — adding a stateful, write-classified capability without leaking its concerns into the shared core, and proving it with a diff rather than an assurance. Second, can they do agentic AI engineering deliberately — with a documented threat model, an append-only decision log, a real test pyramid, and a build process transparent enough to review. The voxel castle is the memorable part; the discipline behind it is the point.