A field guide · October 2026

The MCP Field Guide

Connecting models to the world, one server at a time
by Mat Siems
Part I

The N-by-M Problem

Why a protocol exists, and why now.

Chapter 1 · Part I

A Plug for Every Socket

Welcome. This is a field guide to the Model Context Protocol, usually shortened to MCP, as it stands in October 2026. It has a hundred short chapters, each meant to teach you one thing you can use this week, whether you build servers, run the hosts that connect to them, or have been asked by someone senior to "have a view on MCP" by Friday.

Start with the plain description. MCP is an open protocol that lets an AI application connect to external tools and data through one standard interface. On one side sits something that talks to a model: a chat app, a coding agent, an IDE. On the other sits something that knows how to do a job: search a ticket tracker, query a database, read a folder, send a message. MCP is the agreed shape of the conversation between them. The application asks what is available, the other side describes it, and from then on the model can request that work be done and receive the results.

The comparison everyone reaches for is USB-C, and for once the cliché earns its keep. Before a common port, every device came with its own cable and every drawer filled with the wrong ones. After it, a manufacturer builds one socket and trusts that whatever arrives will fit. MCP does the same for the space between models and the world. Build a server once, and any host that speaks the protocol can plug it in. Build a host once, and it can use any server.

A protocol is boring on purpose. That is how it gets to be everywhere.

What does this mean in practice? It means that when you want your assistant to read your company wiki, you no longer wait for the assistant's vendor to write a wiki integration, nor do you write one yourself in a vendor-specific plugin format that will be deprecated by spring. You find, or build, an MCP server for the wiki, and you connect it. The same server then works in your coding agent, your desktop chat app and the internal tool your platform team is building, because they all speak the same language.

It also means a small shift in how you think about the model. A model on its own knows what it was trained on and what you paste into it. A model with MCP servers attached can look things up, take actions and fetch fresh context when it needs it, within the limits you set. That last clause will occupy a good third of this book, because a plug that fits everything also fits things you did not intend.

The rest of Part 1 explains why the protocol exists, where it came from and what it is not. If you are impatient, skip to the tenth chapter and connect something. You will come back. Everyone does, usually right after the first tool call that surprises them.

One socket, any plug HOSTS · talk to a model SERVERS · know a job Chat app desktop · web Coding agent terminal IDE editor MCP one standard interface 1 what is available? 2 server describes 3 request the work 4 results return Ticket tracker search Database query Folder read Messages send Build a server once: every host that speaks MCP can use it. Build a host once: it can use every server.
Fig 1 · A Plug for Every Socket. Hosts and servers meet through one standard interface: ask, describe, request, return.
Chapter 2 · Part I

Multiplication Is the Enemy

Every integration problem is secretly a multiplication problem, and multiplication is the enemy. Suppose there are five AI applications your organisation cares about and twenty systems you want them to reach. If each application integrates with each system on its own terms, you need a hundred integrations. Each will be written by a different person, in a different style, with a different idea of what an error looks like. Each will break on its own schedule.

This is the N-by-M problem, and it is older than language models. It is why we have SQL drivers, printer drivers, HTTP and the humble power socket. In every case the fix was the same: agree on a shape in the middle. Then each application implements the shape once, and each system implements it once, and the hundred integrations collapse into twenty-five pieces of work. N plus M, not N times M. The arithmetic gets more persuasive as the numbers grow, and in AI tooling the numbers grew very fast.

Before MCP, every model provider and every agent framework had its own way of describing a tool. They were all similar, because they were all JSON Schema with a name and a description, but similar is not the same. A tool written for one framework had to be rewrapped for the next. A company that wanted its product reachable from AI assistants had to pick favourites, or ship five slightly different plugins and maintain all of them. Most picked one and hoped.

Integration cost grows with the product of your choices. Standards make it grow with the sum.

MCP moves the agreement down a layer. It does not care which model is behind the host, nor which language the server is written in. It cares that both sides exchange the same messages: list your tools, call this one, here is the result. Once that is fixed, the people who know the ticket tracker build the ticket tracker's server, and the people who build hosts concentrate on hosting. Each party does the work they are best placed to do, once.

There is a cost, and it is worth naming. A shared shape is a compromise. Some systems have capabilities the protocol does not express neatly, and some hosts would like features the protocol does not yet offer. You will meet both frustrations. The trade is still a good one, for the same reason nobody designs a bespoke plug for their kettle: the value of fitting everywhere is larger than the value of fitting perfectly anywhere.

So when someone asks you why your team should use MCP rather than writing a direct integration, do the arithmetic aloud. Count the hosts you will want to support in two years, count the systems, and multiply. Then count again and add. The gap between those two numbers is the whole business case, and it rarely needs a slide.

Multiplication is the enemy Point to point apps systems One shape in the middle apps systems MCP each pair built and broken separately each side implements the shape once N × M = 5 × 20 = 100 integrations to write and maintain N + M = 5 + 20 = 25 pieces of work, each done once Cost grows with the product of your choices; a standard makes it the sum.
Fig 2 · Multiplication Is the Enemy. Five apps and twenty systems: a hundred point-to-point links versus twenty-five via MCP.
Chapter 3 · Part I

Life Before the Protocol

It helps to remember what we did before, if only to stop anyone nostalgically suggesting we do it again. Language models learned to call functions some time before MCP existed. You described a function with a name, a sentence of explanation and a JSON Schema for its arguments; the model replied, not with prose, but with a structured request to call it; your code ran the function and fed the answer back. This worked. It still works. It is, in fact, exactly what happens underneath MCP.

The trouble was everything around it. Each provider's API had its own envelope for tool definitions and tool results. Each agent framework wrapped those envelopes again in its own abstractions, with its own decorators and base classes. A team that wanted its assistant to search their documentation wrote a search function, wired it into one framework, and discovered six months later that half the company used a different assistant which could not see it. The function was fine. The glue was the problem, and the glue was bespoke every time.

Then came plugin ecosystems. Several products offered a way for third parties to extend them, each with its own manifest format, review process and lifecycle. A plugin built for one product was useless to another. Some of those ecosystems were retired, taking their plugins with them. If you built on one, you learned the lesson every platform teaches eventually: you were a tenant, not an owner.

Glue code is the dark matter of software. It holds everything together and nobody can see how much of it there is.

There was also a subtler cost. Because every integration lived inside a particular application, the integration knew too much about that application. It assumed a certain model, a certain prompt style, a certain way of asking the user for permission. Moving it meant untangling those assumptions. Testing it meant running the whole application. Reusing it meant copying it, and copying meant two versions drifting apart.

MCP's answer is separation. The server knows about the system it wraps and nothing about the model. The host knows about the model and the user and nothing about the system's internals. The protocol is the narrow, well-specified gap between them. That gap is where reuse becomes possible, and where testing becomes possible without a model in the loop.

None of this was a failure of imagination by the people who came before. Function calling was the right primitive. Plugins were a reasonable experiment. They simply lacked a neutral middle that nobody owned and everybody could implement. If you are maintaining a pile of pre-MCP integrations today, you do not need to rewrite them in a weekend. Wrap the most reused one as a server, connect it to two hosts, and see whether the glue drawer gets lighter. It usually does, and the drawer never gets heavier again.

Three ways to reach a tool Function calling Plugins MCP server Definition provider envelope product manifest one shared schema Reuse rewrap each time useless elsewhere any MCP host Who owns it the application the platform nobody; all Knows about model, prompt, app one product only its system Test it alone run the whole app run the product call it directly Function calling was the right primitive; the glue around it was bespoke. MCP adds the neutral middle nobody owns and everybody implements.
Fig 3 · Life Before the Protocol. Function calling, plugins and MCP servers compared on format, reuse, owner and testing.
Chapter 4 · Part I

A Short History of a Young Standard

The history is short because there has not been much calendar for it. Anthropic published the Model Context Protocol as an open specification in November 2024, with SDKs and a handful of reference servers for things like filesystems, Git and databases. At launch it was one company's proposal, implemented in that company's desktop app, with a promise that anyone could build on it. Promises like that are common. Most are not taken up.

This one was. Through 2025 the protocol was adopted by a remarkable spread of hosts: other model providers' assistants and agent toolkits, the major IDEs and coding agents, and a long tail of smaller tools. Companies began shipping official servers for their products, and the number of community servers grew faster than anyone could usefully count. By the end of that year, "does it support MCP?" had become a routine question in tool evaluations, asked in the same tone as "does it have an API?"

The specification itself moved quickly. Revisions are identified by date rather than by version number, and each one added or tightened something: a streaming HTTP transport to replace an earlier, clumsier one; an authorisation framework built on OAuth; structured tool output; ways for a server to ask the user a question; machinery for long-running work. Some early features were removed when they proved more trouble than they were worth. That is a healthy sign. Standards that never subtract anything become museums.

A standard becomes real the day its author stops being its only implementer.

In December 2025 Anthropic handed MCP to a newly formed open foundation under the Linux Foundation, alongside contributions from other companies. The practical effect is that the protocol is now governed in the open, with proposals, working groups and maintainers drawn from several organisations, rather than being one vendor's roadmap. For a buyer, that answers the question people always ask about a young standard: what happens if the company behind it changes its mind?

What should you take from the history? Mainly a sense of tempo. Details have changed every few months and will keep doing so. Field names get renamed, capabilities get added, deprecated mechanisms linger in older servers for a while. This book therefore leans on principles, and where it names a specific mechanism it tells you why the mechanism exists, so that you will recognise its successor.

There is also a lesson in why it spread. MCP was not the cleverest possible design. It was simple enough to implement in an afternoon, open enough that nobody had to ask permission, and useful on the first day. Those three properties beat cleverness nearly every time. If you ever find yourself designing an internal standard, remember the order: useful, then open, then simple, then, only if there is time left, clever.

A young standard, quickly adopted Open spec SDKs + ref servers Nov 2024 Hosts adopt it assistants · IDEs 2025 Spec revisions dated revisions 2025–26 Linux Foundation open governance Dec 2025 Default question asked like API? Oct 2026 added: streamable HTTP · OAuth · structured output · elicitation · tasks Why it spread: useful, then open, then simple. Clever came last.
Fig 4 · A Short History of a Young Standard. From open spec in November 2024 to Linux Foundation governance in December 2025.
Chapter 5 · Part I

The Model Only Talks

The single most useful fact about MCP is also the one most often misunderstood. The model never calls a tool. The model only talks. When people say "the model searched the database", what actually happened is that the model produced some text saying, in a structured way, I would like the search tool to be called with these arguments, and a piece of ordinary software decided whether to do it.

That piece of software is the host: the chat app, the coding agent, the IDE. The host has given the model a list of tools it may ask for, each with a name, a description and a schema. When the model's reply contains a tool request, the host reads it, checks its own rules, perhaps asks you for permission, and then sends the request over MCP to whichever server provides that tool. The server does the work and returns a result. The host places the result back into the conversation, and the model, reading it, decides what to say or ask for next.

Why does this matter? Because every safety property, every permission, every audit log lives in the host and the server, not in the model. A model cannot exceed its tools, because it cannot do anything at all except produce text. If a server exposes a tool that deletes records, the model can ask for records to be deleted; whether that happens depends on the host's approval rules and the server's own checks. If neither checks, the model's judgement is the only guard, and the model's judgement can be influenced by anything in its context.

The model proposes. The host disposes. The server does the work and keeps the receipts.

This also explains why MCP servers do not need to know which model they serve. They receive a well-formed request and return a well-formed result. Whether that request originated in a frontier model, a small local one or a test harness typing JSON by hand is invisible to them, and should be. Some of the best debugging you will ever do is calling a server directly, with no model in sight, to see whether the problem lives above or below the protocol.

It explains, too, why tool descriptions matter so much. The model chooses what to request based entirely on what it has been told. A tool called query described as "runs a query" will be requested at strange moments with strange arguments. A tool called search_open_tickets described as "finds open support tickets matching a phrase; returns at most twenty" will be requested when it should be. The model cannot read your source code. It reads your adjectives.

Keep the sequence in your head: model asks, host decides, server acts, result returns. When something goes wrong, ask which of the four steps failed. Most confusion about agents comes from imagining a fifth step in which the model reached out and did something by itself. It did not. Something you configured let it.

The model only talks User Model Host Server asks a question question + tool list text: call search_tickets(q) check own rules ask permission? tools/call does the work result result placed in context answer The model proposes. The host disposes. The server does the work.
Fig 5 · The Model Only Talks. The model emits text; the host checks rules, calls the server and returns the result.
Chapter 6 · Part I

Context Is the Product

The name tells you the job, if you read it slowly. Model Context Protocol. Not a tool protocol, though tools are its most famous feature, and not an agent protocol, though agents use it heavily. It is a protocol for getting context to a model: the right facts, the right files, the right capabilities, at the moment the model needs them.

A model's usefulness is bounded by what is in its context window. It can reason only about what it can see. Before protocols like MCP, the main ways to get context in were to paste it by hand, to stuff a retrieval system's best guesses into the prompt, or to fine-tune. All three have their place. All three share a weakness: somebody had to decide in advance what the model would need. MCP lets the model, or the application around it, fetch context on demand. Ask a question about last week's incidents and the assistant can go and look, rather than relying on whatever happened to be pasted in.

This framing explains the protocol's three server-side primitives better than any diagram. Tools let the model fetch or change things when it decides to. Resources let the application attach data, such as a file or a record, directly to the conversation. Prompts let the user pull in a prepared recipe. All three are ways of moving the right material into the model's view. All three cost space in a finite window.

Context is not free. Every token you hand the model is a token it must read past to find the one that matters.

That cost is the quiet constraint behind much of good MCP design. A server that returns ten thousand rows has not been generous; it has been rude. A host that loads the full definitions of two hundred tools before the first message has spent a large share of its budget on menus. Good servers return less and point to more. Good hosts load tool definitions lazily and let the model search for what it needs. You will see both ideas again in later parts.

There is a practical habit that follows. When you evaluate a server, do not only ask whether it can do the job. Ask how much context it spends doing it. Call a tool by hand and look at the size of what comes back. Count the tools it advertises and read their descriptions as if you were a model with a small desk and a deadline. A server that answers in two hundred words where a rival answers in two thousand is not less capable. It is more considerate, and considerate servers produce better answers, because the model has room left to think.

The protocol carries context. Your job is to make sure it carries the right amount. A funnel, not a firehose.

Context is the product Tools model fetches, acts Resources app attaches data Prompts user pulls a recipe Context on demand fetched when needed Finite context window every token must be read past The right amount room left to think Better answer Firehose 10,000 rows back Funnel less data, more links 200 tool defs up front load tools lazily Every token you hand the model is one it must read past.
Fig 6 · Context Is the Product. Tools, resources and prompts funnel into a finite window: return less, link more.
Chapter 7 · Part I

Borrowed Ideas, Honestly Credited

Good standards are mostly borrowed, and MCP is honest about its debts. The clearest one is to the Language Server Protocol, which solved a strikingly similar problem for code editors a decade earlier. Before LSP, every editor needed its own plugin for every language to get completion, go-to-definition and error squiggles. After it, a language team wrote one language server and every editor that spoke the protocol got the features. N by M became N plus M. Sound familiar?

MCP's designers took more than the arithmetic. They took the shape. In LSP a client, the editor, launches a server, often as a subprocess talking over standard input and output, and the two exchange JSON-RPC messages. They begin with an initialisation handshake in which each side declares its capabilities, so neither has to guess what the other supports. They continue with requests, responses and notifications flowing in both directions. If you have ever debugged a language server, you already understand more of MCP than you think.

The second debt is JSON-RPC 2.0, a small, old and deliberately dull specification for remote procedure calls encoded in JSON. A message is a request with a method name, parameters and an id; or a response carrying a result or an error for that id; or a notification, which is a request that expects no answer. That is nearly all of it. MCP adds its own methods on top, such as listing tools or reading resources, but the envelope is unchanged JSON-RPC. Libraries for it exist in every language, which is one reason MCP servers appeared in so many languages so quickly.

Nobody gets credit for inventing the envelope. Everybody benefits from not reinventing it.

Other debts are less direct. OAuth supplies the authorisation story for remote servers, in full rather than in spirit. JSON Schema describes tool inputs and outputs. URIs name resources. Server-sent events carry streams over HTTP. None of these was invented for MCP, and that is precisely their value: each arrives with tooling, documentation and a generation of engineers who already know its sharp edges.

Why should a practitioner care about lineage? Because borrowed ideas come with borrowed answers. When you wonder how to handle a cancelled request, the LSP and JSON-RPC worlds have opinions. When you wonder how to validate a token, the OAuth world has a decade of hard lessons, many of them written in the form of security advisories. Reading one good article about language server design will make you a better MCP server author than reading ten breathless posts about agents.

The overlap is the protocol, and the protocol is mostly overlap. That is not a criticism. The best compliment you can pay a standard is that its pieces were already trusted before anyone assembled them.

Borrowed ideas, honestly credited LAYER BORROWED FROM MCP methods tools/list · resources/read MCP's own part Handshake + capabilities initialize · declare features LSP Message envelope request · response · notification JSON-RPC 2.0 Transports stdio subprocess · HTTP streams LSP + SSE CROSS-CUTTING JSON Schema tool inputs + outputs URIs resource names OAuth remote authorisation The protocol is mostly overlap; its pieces were trusted first.
Fig 7 · Borrowed Ideas, Honestly Credited. MCP's layers and what each borrows from LSP, JSON-RPC, SSE, JSON Schema, URIs, OAuth.
Chapter 8 · Part I

What MCP Is Not

Every successful technology attracts claims it never made. MCP has collected its share, so it is worth spending a chapter on what it is not. This saves meetings.

It is not an agent framework. MCP does not decide when to call a tool, how to plan a multi-step task, how to retry, or when to stop. Those choices belong to the host and the model inside it. A framework may use MCP to reach tools, and many do, but the protocol has no opinion about loops, memory or reasoning. If you are choosing between MCP and an agent framework, you have misread one of them.

It is not a replacement for your API. An MCP server usually sits in front of an existing API and translates it into a shape a model can use well. The API still exists, still serves your web app and your partners, and still carries the real business logic. A server that duplicates that logic rather than calling it will drift. Think of the server as a well-briefed receptionist, not a second building.

It is not a security model. MCP specifies how authorisation should work for remote servers and gives hosts the information they need to ask for consent. It cannot make a malicious server honest, a careless server careful, or a model immune to instructions hidden in data. Security is something you build with MCP, out of hosts, servers, tokens and policies. It is not something MCP hands you by being installed.

A protocol tells you how to speak. It cannot tell you whom to trust.

It is not a model feature. Models are trained to use tools, but MCP lives entirely outside the model, in the software around it. That is why the same server works with different models, and why a host can support MCP with a model that has never heard of it.

It is not a marketplace, though registries exist; not a hosting platform, though many companies will host servers for you; and not a guarantee of quality, though people sometimes treat a server's existence as proof that it works. A server is code somebody wrote. Some of it is excellent. Some of it was written in an afternoon and never touched again.

So what is it? A protocol: a precise agreement about messages, their order and their meaning, between a client acting for a host and a server offering capabilities. That is a smaller claim than the hype, and a far more durable one. When someone in a meeting proposes MCP as the answer to a problem, ask one question first: is this a problem about two pieces of software agreeing how to talk? If yes, MCP may well help. If no, it is the wrong tool, however fashionable the acronym.

What MCP is not MCP IS NOT… …BECAUSE An agent framework planning lives in host + model A stand-in for your API it sits in front of the API A security model you build security with it A model feature it lives outside the model A marketplace or host registries + hosting are separate A quality guarantee a server is code somebody wrote It is a protocol: messages, their order and meaning between a client acting for a host and a server offering capabilities
Fig 8 · What MCP Is Not. Six things MCP is not, and why; what it is: a protocol between client and server.
Chapter 9 · Part I

The Shape of an Ecosystem

A protocol on its own is a document. An ecosystem is what happens when enough people implement it that implementing it becomes the default. MCP crossed that line quickly, and it helps to know the main inhabitants before you go looking for anything.

Servers are the most numerous. Some are official, built and maintained by the company whose product they wrap: a ticket tracker's own server, a cloud provider's, a payments company's. Some are community-built, often for products that have no official server yet, and vary from superb to abandoned. Some are internal, built by companies for their own systems and never published. When you choose a server, those three categories carry very different expectations about support and security, and you should know which one you are dealing with.

Hosts are the applications that connect to servers on behalf of a user and a model. They include chat assistants on desktop and web, coding agents in the terminal and the IDE, and a growing number of business tools that have quietly become hosts because they added an assistant. Hosts differ in which parts of the protocol they support. Nearly all support tools. Fewer support every client-side feature. Part 6 tours the main ones.

SDKs sit between the two. Official SDKs exist for the major languages, maintained alongside the specification, and they handle the dull parts: message framing, the handshake, capability negotiation, transports. Most servers you meet were built on one. Most servers you build should be too.

Ecosystems are built by people solving their own problem in a way that happens to solve yours.

Registries are how anyone finds anything. There is an official registry of server metadata, maintained in the open, which other catalogues and host directories can build on. There are curated directories inside the major hosts, where an administrator can switch on a vetted connector without anyone touching a config file. And there are the informal lists that every ecosystem grows, some carefully maintained and some mostly enthusiasm. Part 9 covers discovery properly.

The network effect is real and runs in both directions. Each new host makes every existing server more valuable, and each new server makes every host more useful. That loop is why MCP spread, and it is also why the ecosystem has a quality problem: when building a server is easy and publishing one is free, the number of servers grows faster than anyone's ability to vet them.

Your practical move this week is a small inventory. List the hosts your team already uses, and for each, the servers it connects to. Note which are official, which community and which internal. Most teams that do this are surprised by both lists. Surprise is fine. Ignorance is the expensive version.

Who lives in the ecosystem MCP ecosystem Servers official community internal Hosts chat apps coding agents business tools SDKs message framing handshake transports Registries MCP registry host catalogues informal lists More hosts each server worth more More servers each host more useful network effect servers outgrow anyone's vetting This week: list your hosts, their servers, and who built each one.
Fig 9 · The Shape of an Ecosystem. The ecosystem: servers, hosts, SDKs and registries, linked by a two-way network effect.
Chapter 10 · Part I

Your First Ten Minutes

Theory is pleasant, but nothing teaches MCP like watching a tool call happen. Spend ten minutes on this now and the next ninety chapters will make more sense.

Pick a host you already use. If it is Claude Code, open a terminal in a project and add a server with the claude mcp add command; if it is a desktop chat app, find its connectors or extensions settings. Choose a server whose job you understand completely and whose blast radius is small: a filesystem server pointed at a scratch folder, a documentation server for a library you know, a read-only connector to a tool you use daily. Avoid anything that can send email or move money. You are learning, not auditioning.

Once it is connected, check that the host can see it. Most hosts show connected servers and their tools somewhere obvious; in Claude Code, the /mcp command lists them with their status. Read the tool names and descriptions. This is exactly what the model will read, and it is worth seeing through its eyes. Are the descriptions clear? Would you know when to use each one?

Now ask a question that needs the server. Not "use the filesystem tool", which teaches you nothing, but a real question whose answer lives behind the server: which files in this folder mention invoices, or what does the documentation say about retries. Watch what happens. The host will show the model's tool request, often with its arguments, and may ask your permission. Approve it. Then look at the result the server returned before the model summarised it.

The first tool call is a magic trick. The second is a mechanism. Aim to get to the second quickly.

The last step is the one people skip. Verify. Check the answer against the source yourself. Did the model call the tool you expected, with sensible arguments? Did the server return what you would have returned? Did the summary match the result, or did the model embroider? You are calibrating three things at once: the server's quality, the model's judgement and your own sense of how much to trust the pair.

Then do one more thing. Ask a question the server cannot answer, and see whether the model admits it or invents something. A good combination will say it could not find the information. A poor one will make it up with confidence. Knowing which you have is worth more than any benchmark.

If you followed along, you now understand the protocol's loop better than most people who talk about it: discover, ask, call, return. Everything else in this book is detail on one of those four words, plus the security considerations that arrive the moment you connect something more interesting than a scratch folder. Enjoy the scratch folder while it lasts.

Your first ten minutes Pick a host you already use Add a small server a scratch folder Check it is visible /mcp · read the tools Read the raw result before the summary Approve the call watch the arguments Ask a real question answer lives behind it Verify the answer check it against source Probe its limits ask what it cannot know Admits it? yes Trustworthy pair says it found nothing no Invents: trust it less The loop you just watched discover ask call return everything else in the book is detail on one of these four words The first tool call is a magic trick; the second is a mechanism.
Fig 10 · Your First Ten Minutes. A first session: connect a small server, ask, approve, read the raw result, verify.
Free preview · Part I

Keep reading

You have read the first 10 of 100 chapters of The MCP Field Guide. The full book has every chapter and plate, as PDF and EPUB in English, French, Polish and Spanish.

The full book is coming soon to the shop.

Already bought it? Read the full edition online

The MCP Field Guide · First Edition, October 2026
100 chapters · 10 parts · one hundred diagrams
by Mat Siems · MS Books, No. 13 · 2026