The GIS Intent Compiler
Natural language in. Correct geospatial pipelines out. Or an honest refusal. ForgeMind is the natural-language control plane for ForgeGIS — it turns a plain-language request into a validated, executed pipeline on the GPU-accelerated engine, and when a request cannot be honored correctly it returns an explicit refusal rather than a confident guess.
Three short answers for the technical evaluator.
ForgeMind sits between a human (or another agent) and the ForgeGIS™ compute engine. It decides what to run, binds the request to real data, dispatches the work, and narrates the result — turning informal language into a correct, reproducible operation. It speaks the Model Context Protocol natively in both directions.
A conventional agent lets a model author tool chains directly, so every wrong parameter and hallucinated step lands in production looking confident. On its compiled path, ForgeMind refuses by construction: a request either compiles to a validated pipeline or is declined. That is what regulated and mission work requires.
The language model classifies intent and extracts parameters only. Deterministic code owns pipeline structure, type-checking, and execution — so the same request yields the same pipeline every time, with no hallucinated params and no drift. Cheap work runs on a fast model tier; the costly tier is reserved for the hard step.
ForgeMind treats a natural-language request the way a compiler treats source code. The language model does one narrow job — extract intent into a typed intermediate representation. From there, deterministic machinery takes over.
| Typical LLM agent loop | ForgeMind compiler | |
|---|---|---|
| What the LLM does | Plans and executes, reasons about geometry directly | Extracts intent into a typed IR, nothing more |
| Where math happens | Inside the model's reasoning (unverifiable) | Deterministic engine · GPU-accelerated ForgeGIS |
| Failure mode | Plausible, confident, wrong | Explicit refusal. Never a fabricated number |
| Cost / latency | Many model calls per task | One intent pass, then deterministic execution |
| Auditability | Opaque chain of thought | Inspectable IR for every single turn |
The internal GIS Intent Compiler is proprietary; what follows is the externally observable contract each commitment produces.
Every candidate pipeline is checked against a type system and operational guards before any work is dispatched. A request that cannot be mapped to a valid operation, lacks its parameters, or cannot bind to data is refused with a specific, machine-readable reason — never run speculatively. A request the compiler cannot route may instead fall back to a guarded agent loop, where the model chooses the tool calls; structural failures and out-of-scope requests are refused outright.
The language model is confined to classifying what the operator wants and extracting parameters. The shape of the pipeline is owned by deterministic machinery, so for a templated capability the same parsed intent produces the same pipeline every time — no hallucinated parameters in the pipeline, no operation-arity slips.
With a hosted vendor, cheap, high-volume classification runs on a fast, low-cost tier and the more capable tier is kept for requests no template covers; most answers are now narrated from templates with no model call at all. On one site-suitability request (Claude, May 2026) the compiled path cost roughly a twenty-fifth of a legacy agent-loop run, which hit its iteration cap without finishing. In the suite a local model runs every stage on one model, on your own hardware.
The provider and model sit behind one abstraction — configuration, not architecture. Switch models to follow cost, capability, availability, or procurement constraints (including continuity during a provider outage) without code changes. Claude, OpenAI, Gemini, and Grok ship built in, and a model you host yourself on any OpenAI-compatible server — Ollama is the tested path — plugs into the same integration point.
As a client it dispatches to MCP tool servers — the ForgeGIS compute surface, a dataset
catalog, a map client — guarding each namespace behind a circuit breaker. As a server it
exposes a single high-level tool a higher-order agent can hand an entire geospatial workflow to, plus a structured surface — list_capabilities and run_capability — that runs capabilities with no model call at all.
Ask in ForgeGIS Studio and the contours, profiles, and draped rasters land on Studio's map; ask in Seaglass Globe's Assistant and they land on the globe. Each request carries the window it came from, along with the scene you were looking at, so the answer goes back to it.
Named geometry a user places on a map — a dock, a route, an objective — is referenced by a stable handle and hydrated from the catalog on demand, never re-derived from a bounding box. Fail-closed: if the true geometry is not reachable, the operation defers and asks rather than emitting a plausible-but-wrong product.
A scripted test scenario simulating a combat search-and-rescue plan, run end to end against real SRTM terrain. The test harness supplies each turn's intent, so what it exercises is routing, type-checking, entity memory and execution — and all 102 operations succeeded.
ForgeMind makes the ForgeGIS catalog reachable in natural language, anchored on a deterministic core of routed capabilities. Coverage grows capability by capability as each is validated; ForgeMind advertises only what it can run correctly.
ForgeMind is validated along two complementary axes — a large multi-turn conversation campaign that measures end-to-end behavior as an operator would experience it, and a focused compiler-evaluation campaign that measures the core intent-to-pipeline transformation in isolation.
Full validation methodology and campaign detail: ForgeMind Technical Brief (PDF).
ForgeMind ships as a single self-contained Java application, deployable where the mission runs.
Run it as an HTTP service exposing a small REST surface — a buffered endpoint plus a streaming (SSE) endpoint that surfaces each model round trip and tool call live — or as an MCP stdio server that presents ForgeMind as a single delegatable tool to a higher-level agent host. Auth, rate limiting, request-size caps, and a concurrency cap are built in.
ForgeMind spawns and supervises its MCP backends — the ForgeGIS compute engine, a dataset catalog, and a map client — as local subprocesses over stdio, with health checks and per-namespace circuit breakers. ForgeGIS is the engine it is built to drive; the catalog and map-client roles are pluggable behind the protocol.
A pure-JVM application with local-disk persistence and no required external services beyond the language-provider endpoint. The memory store is a single local database file; backends run over stdio, not the network. An air-gapped site points ForgeMind at a model server on its own network — any OpenAI-compatible server, with Ollama the tested path — so no request goes to a cloud model at all.
One product, three readers. Each one-pager leads with the parts of ForgeMind that matter most to that audience.
A natural-language control plane that refuses rather than fabricates. The line-of-sight surface — viewshed, intervisibility, terrain-constrained suitability — reachable by intent; named entities resolved against real geometry; pure-JVM, local-disk, deployable where the mission runs.
Download defense & IC one-pager (PDF)
Consumes MCP tools and exposes itself as a single MCP tool a higher-level agent can hand a
whole geospatial workflow to. Compile intent into a validated pipeline deterministically —
a zero-model structured surface (list_capabilities / run_capability), and an inspectable IR for every compiled turn.
Ask for a geospatial product in plain language — a viewshed, a slope mask, a site-suitability search — and get a correct result without learning a desktop GIS. ForgeMind holds context across a conversation, so a subject is established once and refined across turns.
Download general sales one-pager (PDF)All ForgeMind collateral. Direct download — no email gate, no form wall.
Architecture, the four providers and local models, capabilities, what each validation figure rests on, and deployment. Updated for 1.2.5.
Download PDFThe full 102-operation scripted session, request by request, against real SRTM terrain — with an account of how the regression run was made and what it does and does not show.
Download PDFFront/back overview. General-purpose first-touch document covering positioning, the compiler model, and who ForgeMind is for.
Download PDFFor defense and intelligence programs, prime integrators, and SI shops. Leads on refusal-by-construction, the line-of-sight surface, and disconnected deployment.
Download PDFFor AI agent builders, LLM agent platforms, and MCP-native runners. Leads on the two-way MCP surface, the zero-model capability surface, and the compile-don't-loop architecture.
Download PDFLicensing questions, evaluation access, partnership and distribution inquiries — we read every email. ForgeMind is commercially licensed; terms are provided on request, and an evaluation build is available to qualified teams.
rich@seaglassfoundry.com