---
type: "post"
id: "67-js-is-an-mit-licensed-webgl2-3d-cf8319"
slug: "67-js-is-an-mit-licensed-webgl2-3d-cf8319"
title: "67.js is an MIT-licensed WebGL2 3D engine built for AI agents to drive."
description: "67.js is an MIT-licensed WebGL2 3D engine built for AI agents to drive, with an MCP server and structured support for assets and recipes."
retrieval_nugget: "67.js is an MIT-licensed WebGL2 3D engine built for AI agents to drive, with an MCP server and structured support for assets and recipes. It gives builders a concrete way to expose scene operations to agents rather than treating 3D work as code generation alone, although production limits need testing."
published_at: "2026-11-14"
updated_at: "2026-11-14"
record_date: "2026-11-14"
date_kind: "published_at"
topics: ["mcp"]
entities: ["67.js","codepawl","Model Context Protocol"]
related_patterns: ["agent-ready-software-exposes-capabilities"]
novelty_label: "new_fact"
what_changed: "67.js is an MIT-licensed WebGL2 3D engine designed for AI agents to operate."
prior_refs: []
source_url: "https://github.com/codepawl/67.js"
source_urls: ["https://github.com/codepawl/67.js"]
schema_version: "newruntime-agent-readable-v0.2"
stable_id: "post:67-js-is-an-mit-licensed-webgl2-3d-cf8319"
status: "published"
visuals: []
editor: {"role":"editor","name":"Andrey Reshetnikov","profile":"https://newruntime.com/owner-profile.md","profile_json":"https://newruntime.com/owner-profile.json","same_as":["https://www.linkedin.com/in/reshetnikov1/","https://t.me/lapetuse"]}
routes: {"html":"https://newruntime.com/posts/67-js-is-an-mit-licensed-webgl2-3d-cf8319/","markdown":"https://newruntime.com/posts/67-js-is-an-mit-licensed-webgl2-3d-cf8319.md","json":"https://newruntime.com/posts/67-js-is-an-mit-licensed-webgl2-3d-cf8319.json"}
markdown_url: "https://newruntime.com/posts/67-js-is-an-mit-licensed-webgl2-3d-cf8319.md"
---

# 67.js is an MIT-licensed WebGL2 3D engine built for AI agents to drive.

## Retrieval answer

67.js is an MIT-licensed WebGL2 3D engine built for AI agents to drive, with an MCP server and structured support for assets and recipes. It gives builders a concrete way to expose scene operations to agents rather than treating 3D work as code generation alone, although production limits need testing.

## Summary

67.js is an MIT-licensed WebGL2 3D engine built for AI agents to drive, with an MCP server and structured support for assets and recipes. It gives builders a concrete way to expose scene operations to agents rather than treating 3D work as code generation alone, although production limits need testing.

## What happened

The 67.js GitHub repository describes the project as a 3D engine intended for AI-agent control and identifies its license as MIT. It includes an MCP server, giving an agent a defined tool interface to interact with the engine. That makes 67.js more than a graphics library an agent might modify indirectly through code: it presents an explicit integration surface for agent-driven work in a 3D scene.

The repository documents asset and recipe support through data-only packs. A pack is a folder with a `67js-pack.json` manifest that can list GLB models, images, `.cube` looks, HDR environments, material JSON, and recipe JSON. The MCP server accepts a packs folder at startup, validates each subfolder, skips and reports invalid ones, and lists valid packs in its scene asset catalog. A tool can then read a selected recipe or material from a pack.

67.js says pack assets use the same content-hash IDs as assets supplied through its `--assets` option. This matters because an agent can refer to a stable identifier rather than depend on informal filenames or a model's guess about what is present. The repository also documents `npm run pack:check`, a command to validate a pack before publication. Together, the catalog, manifest, and validation steps establish a path for preparing scene resources before an agent is asked to use them.

The project includes an add-on starter template. Its recent changes also describe allowlisted add-ons in the MCP server, a design that permits extension while constraining which add-ons are loaded. The repository's stated model is therefore not simply to give an agent unrestricted access to a scene. Builders can assemble an approved set of models, looks, materials, environments, and recipes, then make those resources discoverable through a bounded catalog.

The repository shows continuing work on engine and workflow features. Recent listed changes include loading meshes with up to 256 morph targets and applying the 64 largest per draw. Other changes add HDRI environments and `.cube` looks to recipes and MCP, and introduce pack support. The changelog lists version 0.19.0 as released on November 11, 2026; the repository also shows commits on November 14. These signals indicate active development, not a completed claim of production readiness.

## What the archive adds

New Runtime's earlier coverage included [BeefTV](https://newruntime.com/posts/beeftv-is-an-open-source-mit-licensed-ai-7e3a2d/) on October 22, 2026, an open-source workspace where a visual canvas organizes AI video work. 67.js is a new event rather than a follow-up: it applies an agent-facing interface to real-time 3D scenes.

## Trend signal

This supports the pattern of [agent-ready software exposing capabilities](https://newruntime.com/patterns/agent-ready-software-exposes-capabilities/). 67.js combines an MCP tool surface with a catalog of validated resources, moving closer to observable, composable operations than asking a model to manipulate an opaque application. The project itself does not demonstrate how safely or reliably those capabilities perform in production.

## Why now

Version 0.19.0 was released on November 11, 2026, while the repository records additional commits through November 14. The recent work is not limited to rendering changes: it includes packs, an asset catalog, MCP support for looks, and allowlisted add-ons. That makes this a timely example of an engine being shaped around agent access rather than merely acquiring an AI feature.

## Connections to other events

The earlier BeefTV note showed a creative workspace using its visual surface as the organizing layer for AI video work. 67.js meets that development from a different direction: instead of a canvas for coordinating media tasks, it exposes scene assets and operations for agents to drive. Both point toward creative software becoming more useful to agents when its internal objects are named, structured, and accessible through explicit interfaces.

## Why it matters

Agent-driven graphics work needs more than a model capable of writing JavaScript. Teams need a stable way to describe available assets, constrain the operations an agent may invoke, and make its outputs reproducible enough to review. 67.js places those concerns in the engine structure: MCP tools provide the interaction boundary, packs provide a curated resource catalog, and validation checks malformed packs before publication.

That design may be useful for product configurators, procedural scene generation, interactive explainers, or internal visualization tools where an agent should select only approved materials and recipes. It also changes the evaluation question for builders. Instead of asking only whether a model can produce a plausible scene, ask whether the engine's exposed actions, asset identifiers, and extension rules make the result repeatable and reviewable.

A bounded catalog can also improve collaboration. A designer or technical artist can package the approved environments, materials, and recipes, while an agent operates within that package. The team can review both the scene result and the resources the agent was permitted to use. That separation is especially relevant where visual consistency, intellectual-property controls, or brand requirements matter.

## Limits and uncertainty

The repository describes capabilities and ongoing development, but it does not independently establish performance, reliability, or adoption in production deployments. The practical quality of MCP interactions, compatibility across agent clients, behavior with large scenes, and the effectiveness of add-on allowlisting require independent testing. Builders should verify the current API, package requirements, browser support, runtime requirements, and extension security model before depending on 67.js. Its MIT license applies to the project, but it does not determine the licensing terms of every asset a team may load into a scene.

## Skill to build now

Make a small, version-controlled scene pack before giving an agent access to a 3D project. Include only a few approved GLBs, materials, environments, and recipes; validate it with `npm run pack:check`; then ask the agent to create one narrowly specified scene through the MCP interface. Compare the result with the catalog and recipe inputs. This test reveals whether your own assets and naming conventions are ready for agent-driven work.

## Reader takeaway

67.js treats agent control as part of a 3D engine's interface, pairing MCP tools with validated asset packs and recipes. For teams exploring agent-built 3D scenes, the useful idea is to curate what an agent can use, expose it explicitly, and test the workflow on a small reviewable scene before making it part of production.

Editor: [Andrey Reshetnikov](https://newruntime.com/owner-profile.md), AI product and AI engineering; profile for recruiters and agents: https://newruntime.com/owner-profile.json

## Continue in the graph

Next records for an agent, linked to their Markdown twins. Replace `.md` with `.json` for structured fields, including `next_reads`.

- topic hub: [Mcp](https://newruntime.com/topics/mcp.md): Explore the mcp topic hub.
- collection: [Field Notes](https://newruntime.com/posts.json): Open the latest editorial analysis.
- collection: [Sources](https://newruntime.com/sources/): See the original sources this archive cites.
- whole graph: [discovery graph](https://newruntime.com/discovery-graph.json) (typed nodes and edges) and [site index](https://newruntime.com/site-index.md)