AKL — Agent-Native Geometry + BIM Kernel for Architecture

An open-source, deterministic Rust kernel that lets Codex create, query, edit, and visualize NURBS/BREP geometry and IFC-aligned BIM through natural-language MCP workflows.

Comment

Inspiration

An agent-native, geometry-strong, BIM-infused architectural kernel does not yet exist.

Architectural AI is usually placed on top of software designed for a person using a mouse. The agent clicks through a GUI, produces an opaque mesh, or adds a wall label to geometry that has none of the relationships required of a real building model. Geometry kernels are powerful but generally know nothing about spaces, storeys, hosted openings, types, or properties. BIM systems know about buildings, but their deepest modeling workflows are still organized around human interfaces.

I started AKL because I wanted the model itself to become an API that an agent could reason about: exact geometry and building semantics in one inspectable, versioned contract. The long-term ambition is the geometric breadth associated with Rhino and the semantic breadth associated with Revit, but rebuilt around agents first rather than wrapped in UI automation.

What it does

AKL is an open-source, headless geometry and BIM kernel written in Rust. An agent drives it through versioned JSON commands, a CLI, or an MCP server. There is no GUI inside the kernel.

Its canonical document combines NURBS/BREP freeform geometry, analytic solids, surface intersection and curved booleans with IFC-aligned semantic BIM. It can import and export IFC4X3, produce STEP, glTF, SVG, and DXF artifacts, query geometry and building relationships, and preserve stable identities through edits and round trips.

The command log is the model. Given the same seed and commands, AKL produces byte-identical state and artifacts on the same platform. Exact or certified geometry remains authoritative; meshes are derived previews, never a silent replacement for the kernel. When AKL cannot certify a requested case, it returns a named, structured refusal rather than a plausible-looking result.

What I built during Build Week

AKL had a substantial technical foundation before Build Week. The submitted work is the meaningful extension I built with Codex and GPT-5.6 during the event:

  • A self-contained local Codex plugin packages the native kernel, an architecture-modeling skill, and twelve schema-bound MCP tools. On the supported macOS arm64 target, a judge can install it and model without a Rust checkout or toolchain.
  • A fresh Codex session can turn a natural-language request into deterministic geometry, query its live identity and exact quantities, and embed a certified SVG preview. The final installed-package proof created an 8 × 6 × 3 metre solid, reported its exact 144 m³ volume and 180 m² surface area, and rendered it inside Codex.
  • A browser WebAssembly package brings the canonical in-memory document fold, atomic command batches, stable identity, query, undo/redo, replay, and structured errors into a web environment.
  • Native semantic BIM previews let an agent see an entire supported BIM scene while reporting ownership, coverage, and any omitted opaque IFC content.
  • Imported IFC editing gained bounded hosted doors and windows, deletion and movement of the fill/opening pair, and preservation of the complete host → opening → void → fill relationship graph.
  • IFC query and edit inputs are normalized to metres across metre, millimetre, and conversion-based-foot projects, preventing the kind of unit mistake where a requested four-metre edit silently becomes four millimetres.

How I built it with Codex and GPT-5.6

I set the product direction, representation strategy, invariants, accepted tradeoffs, and the line between shipped capability and the honest frontier. Codex and GPT-5.6 helped turn those decisions into parallel, reviewable implementation waves across Rust, IFC, WebAssembly, MCP, packaging, tests, and documentation.

The collaboration was not “generate code and hope.” Codex inspected the existing architecture, proposed bounded designs, implemented them behind the public schemas, reviewed integration points, ran hostile red-team passes, and converted discovered failures into permanent regressions. It caught issues including JavaScript u64 precision loss, a public-schema compatibility regression, unsafe local-file edge cases, stale BIM preview geometry, and physical-unit errors in imported IFC workflows.

External tools remained the independent judges: OpenCascade for geometry and STEP comparisons, IfcOpenShell for IFC structure and quantities, trimesh for meshes, and ezdxf for drawings. The final external battery passed 123 tests across 51 oracle binaries with zero failures.

Challenges

The hardest challenge was refusing to trade correctness for a smoother demo. Freeform surface intersection, trimmed-shell reconstruction, curved booleans, and IFC carrier editing all have degenerate cases where an answer can look right while being topologically or semantically wrong. AKL therefore follows a “certified or loud” rule: prove the supported result, or identify the missing capability.

Packaging was another real product challenge. “Works from the repository” is not the same as “an agent can install it.” The plugin had to carry the correct native binary, bind itself to the exact twelve-tool schema fingerprint, confine file access, survive restarts deterministically, and never fall back silently to Cargo, PATH, or an adjacent checkout.

IFC units and relationships were equally subtle. A hosted door is not a box with a label: it needs a host, opening, void, fill relation, placement, stable identity, and correct project-unit conversion. Preserving that graph through create, move, delete, import, and export required much more than geometric transformation.

What I learned

Agent-native software is not just existing software with a chat box. The kernel needs commands that are atomic, identities that survive change, schemas that can be inspected before acting, queries that return evidence, previews that state their derivation limits, and errors that teach the agent where the capability boundary lies.

I also learned that determinism and external validation are user experience features. They let an agent retry safely, compare state, explain what changed, and avoid quietly corrupting a building model.

What's next

AKL does not yet claim complete Rhino or Revit parity. The next frontier includes realistic-scale streaming IFC imports, broader hosted-element resize and rotation, general NURBS surface-intersection and T3 boolean classes, wider STEP coverage, and a properly authenticated public remote deployment surface.

The foundation is now runnable: install the Codex plugin, describe a model, query the exact or certified result, see it where the agent works, and export open artifacts. That is the first step toward an open architectural modeling stack designed for agents from the beginning.

Built With

  • 4.3
  • bim
  • brep
  • codex
  • gpt-5.6
  • ifc
  • openai
  • rust
  • webassembly
Share this project:

Updates