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 spoken or typed 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. 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.
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 the same request produces the same pipeline every time — no hallucinated parameters, no operation-arity slips, no run-to-run drift.
Cheap, high-volume classification and narration run on a fast, low-cost tier; the more capable tier is reserved for the genuinely hard reasoning. The measured effect is roughly a 25× reduction in language-model cost versus an agent-loop approach — without sacrificing correctness.
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 and OpenAI ship built in; self-hosted models use the same integration point.
Successful workflows, and corrections to unsuccessful ones, accumulate as retrievable exemplars backed by local storage and on-device embeddings. Learning happens through accumulated retrieval context, not model fine-tuning — so it is inspectable, clearable, and never silently bakes a bad pattern into a model's weights.
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.
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 102-operation test scenario simulating a combat search-and-rescue plan, run end to end in plain English against real SRTM terrain. Every operation was understood, type-checked, routed, and executed — and every one succeeded.
ForgeMind makes the 239-operation ForgeGIS catalog reachable in natural language — anchored on a deterministic core of more than 130 routed capabilities, with 97 exercised end to end in the validation campaign. 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. For programs hosting their own models, the provider abstraction is the single integration point.
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 — ~25× lower model cost, zero confident-wrong results, and an inspectable IR per turn.
Download agent-builder one-pager (PDF)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 validation campaigns, capabilities, and deployment guidance. The substantive document for technical evaluators and engineering reviewers.
Download PDFThe full 102-operation marathon session, operation by operation, against real SRTM terrain — every plain-English request, the operation it compiled to, and the result.
Download PDFFront/back overview. General-purpose first-touch document covering positioning, headline numbers, and the compiler model at a glance.
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 compile-don't-loop architecture, and the cost story.
Download PDFLicensing questions, evaluation access, partnership and distribution inquiries — we read every email. License terms are being finalized; an evaluation build is available to qualified teams on request.
rich@seaglassfoundry.com