ibl.ai Agentic AI Blog

Insights on building and deploying agentic AI systems. Our blog covers AI agent architectures, LLM infrastructure, MCP servers, enterprise deployment strategies, and real-world implementation guides. Whether you are a developer building AI agents, a CTO evaluating agentic platforms, or a technical leader driving AI adoption, you will find practical guidance here.

Topics We Cover

Featured Research and Reports

We analyze key research from leading institutions and labs including Google DeepMind, Anthropic, OpenAI, Meta AI, McKinsey, and the World Economic Forum. Our content includes detailed analysis of reports on AI agents, foundation models, and enterprise AI strategy.

For Technical Leaders

CTOs, engineering leads, and AI architects turn to our blog for guidance on agent orchestration, model evaluation, infrastructure planning, and building production-ready AI systems. We provide frameworks for responsible AI deployment that balance capability with safety and reliability.

Back to Blog

Construct 1.0: Agents Build 3D Models and Label What They Know

ibl.ai EngineeringNovember 2, 2026
Premium

Construct 1.0 turns a plain-language request into a 3D model with named parts, under Apache-2.0. It doesn't scan objects or replace CAD. Its useful idea is that every part is labelled verified, supplied, inferred or decorative.

The Short Answer

Construct 1.0 is an Apache-2.0 tool that lets an AI agent turn a plain-language request into a 3D model with named parts, for Blender and game engines. It doesn't scan objects or replace CAD. Its lesson is provenance: every part says how it is known. With ibl.ai you own all the code and the data your agents reason over.

Construct is small and new. The repository, by Artyom Andreyev, was created on October 24, 2026, and v1.0.0 followed on October 27. It had 102 stars when we checked.

What does Construct 1.0 actually do?

Construct has an AI agent describe an object as data, then turns that description into a hologram page and a 3D model. You ask in plain words, and the agent looks up facts for a named subject. It then writes a scene: a text file listing facts and parts, built from simple shapes.

Construct checks the scene, builds one offline construct.html, and the agent reviews stills from each view.

The 1.0 release adds export to glTF 2.0 and OBJ, with named parts and working joints, plus a Blender add-on. The release notes say the output was checked in Godot 4.7.2 and passes the Khronos glTF Validator.

It works with Claude Code, Hermes, any MCP client or any OpenAI-compatible endpoint. It needs no packages beyond Python 3.10 or newer, though review stills need a Chromium browser and video needs ffmpeg.

Does Construct scan real-world objects into 3D models?

No. Construct doesn't scan anything, despite how it has been described. The input is a sentence. For a named subject, reference photos are "only for comparison" and "never copied into the construct or published".

Three other claims in circulation need correcting too:

ClaimWhat the repository says
It scans objectsIt builds from a text request, and the agent writes the parts
It is MIT-licensedApache-2.0, with versions up to 0.3.0 under MIT. The Blender add-on is GPL-3.0-or-later, and four NetLogo examples are CC BY-NC-SA 3.0
It replaces $25,000-a-seat toolsWe found no source for that figure. Examples are independent reconstructions, and the listed audience is game, 3D, film, education and museum work
Any agent can do itAny can connect, but the three small models tested failed to save a scene in about half of runs

Limits are stated plainly too. The README says it has been tested on macOS only, and masterpiece mode can use up to two hours of frontier-model tokens. Those are honest disclosures, and they are part of why we would trust the project.

Why do provenance labels matter for enterprise AI agents?

Provenance labels make an agent separate what it knows from what it made up, and enterprise output rarely does this. In Construct, every fact and part is marked verified, supplied by you, inferred or decorative, and pressing P colours the model by those labels.

The README's Saturn example shows the value. The rings come from published data, while the cloud bands were designed by the model. Both look equally convincing, and only the label tells them apart.

The same labels travel with the export, in the glTF file's extras.construct field. Construct's check also flags "a claim stronger than its evidence" for repair.

A summary, risk memo or forecast from an agent has this problem in a worse form, because it reads in one confident voice. A reader can't see which sentence came from a record and which was the model filling a gap.

What other agent design patterns does Construct demonstrate?

Construct shows two more patterns worth borrowing, and both are about limiting what a model decides.

Data, not code. "A scene is data, never code": the agent says what the thing is, and Construct decides how it looks. That shrinks what can go wrong and makes the output checkable.

An independent critic. In masterpiece mode, a fresh model compares each version with the best so far without knowing which is which. Only a better version is kept. It stops after two rounds without a win, after 12 rounds, or after two hours.

The author's blind comparisons, on two subjects, showed no visible gain after about round 12. That is a small test, but publishing the stopping rule beats promising perfection.

How can you apply provenance to agents on ibl.ai?

You can write the same discipline into your own agents. On ibl.ai, a Skill is a plain Markdown file, so a domain expert can require an agent to tag each claim as sourced, supplied or inferred. This is a practice you configure, not a built-in label set.

Evaluations can then score whether agents do it, with an LLM judge and human annotation. Transcripts keep the record for review. For the same close reading applied to open-source licenses, see our look at agent builders in K-12.

With ibl.ai you own all the code and the data, the platform is model-agnostic across any LLM, it has no per-seat pricing, and you can deploy anywhere, so those rules live in your perimeter.

ibl.ai is family-owned and operated from New York, NY.

Sources: all Construct facts are from its README, documentation and release notes. Star count as of November 2, 2026.

Why does owning the AI stack matter?

ibl.ai is the agentic AI platform where you own all the code and the data. You self-host the entire stack inside your own perimeter, run it model-agnostic across any LLM and switch anytime, and pay by usage with no per-seat pricing β€” so you can deploy anywhere: your cloud, on-premise, GovCloud, or fully air-gapped.

  • You own all the code and the data

    Full source code under a perpetual license, running on your infrastructure. Not API access to someone else's platform β€” the stack itself is yours.

  • Model-agnostic

    Run any LLM β€” Claude, GPT, Gemini, Llama, Command, or your own fine-tune β€” and switch providers without rewriting the platform.

  • No per-seat pricing

    Usage-based billing against a budget cap you set. Cost tracks what your organization actually uses, not how many people you employ.

  • Deploy anywhere

    Your cloud, your VPC, on-premise, GovCloud, or a fully air-gapped network with no outbound connectivity.

1.6M+ users across 400+ organizations run the platform this way, including NVIDIA, MIT, and Syracuse University.

ibl.ai is family-owned and operated from New York, NY β€” a U.S.-headquartered, domestically-owned long-term partner, not a vendor that sells licenses and moves on.

See the ibl.ai AI Operating System in Action

Discover how leading universities and organizations are transforming education with the ibl.ai AI Operating System. Explore real-world implementations from Harvard, MIT, Stanford, and users from 400+ institutions worldwide.

View Case Studies
Work with our team

Pilots, deployment, and full ownership

Most enterprise engagements are one-time, not subscriptions. You integrate ibl.ai with your own data, deploy it on your own infrastructure, and the engineering hours scale with the work β€” so the price tracks the scope, not your headcount.

Start here

Pilot

from $15K

fixed scope Β· fixed timeline

A time-boxed proof of value on your real data β€” not a slide deck.

Best for: Teams that want to see ibl.ai working before committing.

  • Deployed on your infrastructure or our cloud
  • 1–2 production agents wired to a slice of your data
  • One integration (LMS / SIS / SSO / data source)
  • Weekly working sessions with our engineers
  • Pilot fee credits toward a full engagement
Scope a pilot
Most common

Integration & Deployment

$25K – $80K

one-time Β· not a subscription

Full deployment integrated with your data and systems. Engineering hours scale with scope.

Best for: Organizations rolling ibl.ai out across a department, campus, or business unit.

  • Platform deployed in your VPC, on-prem, or air-gapped
  • Integrated with your data + identity (SSO / SAML)
  • Multiple custom agents built to your workflows
  • Engineering hours proportional to scope
  • You own the data Β· run any LLM you choose
Plan a deployment
Full ownership

Codebase Transfer + Custom AI Engineering

Custom quote

perpetual license Β· you own the stack

We transfer the full source code. You own and self-host the entire platform β€” outright.

Best for: Organizations and enterprises that benefit from perpetual ownership and sovereignty.

  • Complete source-code transfer + perpetual license
  • Dedicated AI engineering team on your roadmap
  • Custom agents, models, and integrations to spec
  • Air-gapped capable Β· zero vendor lock-in
  • Family-owned, New York–based long-term partner
Talk about ownership
You own the code and data Run any LLM β€” Claude, GPT, Gemini, Llama Family-owned & operated from New York, NY