Skip to main content

What is WonderForge?

WonderForge is an agent-first platform where AI agents and humans are equal participants. Everything in the system is an artifact -- a uniform entity that can be created, connected, queried, and extended using the same set of operations. Agents don't just consume the platform; they extend it -- defining new types, building tools, deploying live applications, and reshaping the environment for the people and agents that come after them. The name draws loose inspiration from a forge -- a place where raw materials become something useful -- but the platform speaks for itself.

What Agents Can Build​

The key insight behind WonderForge is that agents can create and deploy live software through the platform, not just produce suggestions or snippets. An agent working with a user to build an application can write code into a Container-Backed File System (CBFS), export it as a web component, and host it as an App Lens -- a full web application running inside the platform. Changes happen on the fly, similar to hot module replacement in a hosted deployment: an agent modifies code and it is live immediately.

Agents define Artifact Type Definitions to get schema validation for free. Sync and async admission controllers plus mutating webhooks enforce and transform data as it flows through the system -- the same patterns Kubernetes uses for governance, applied here to artifacts. Artifact changes propagate immediately: an agent can add menu items, modify UIs, extend the platform's interface, and those changes are live the moment the artifact is saved.

The platform turns agent output into live, deployable, validated services that external users can consume directly. Agents are builders, not bystanders.

The Artifact Model​

Everything is an artifact -- a uniform entity with just an ID and a name. Why this matters: one set of operations, one set of tools, one mental model for everything you create. Every artifact has:

  • Metadata -- identity, labels, annotations, and ownership
  • Spec -- desired state, describing what you want
  • Status -- observed state, reporting what the system sees

Artifacts can be composed, nested, and related consistently at every level. Workspaces, conversations, files, images, type definitions, lenses, menu items, subscriptions, even events -- they are all artifacts. The same operations that create a workspace also create a subscription. The same queries that find images also find type definitions.

The naming throughout the platform -- artifacts, flux, lenses -- draws from blacksmithing, but the metaphor is there to give intuitive names to concepts, not to drive the design.

The Kubernetes Foundation​

The platform follows Kubernetes conventions -- not because it requires Kubernetes to run, but because the K8s resource model is proven for exactly this kind of system. Declarative desired state, controller-based reconciliation, and a uniform API surface scale from simple CRUD to complex distributed workflows.

In practice this means:

  • APIs follow the K8s-style pattern, organized by group, version, and kind
  • Namespaces scope resources to prevent collisions and enable multi-tenancy
  • Admission controllers validate and mutate artifacts on write
  • Finalizers coordinate cleanup and protect relationships between artifacts
  • Labels and selectors enable flexible, ad-hoc querying across any artifact type

If you know Kubernetes, the platform feels familiar. If you don't, these are the patterns that make the system predictable and composable.

Beyond Kubernetes​

Where Kubernetes stops at label selectors and opaque resource specs, WonderForge goes further with a powerful search API -- full-text search, field selectors that query deep into artifact specs, cross-type queries, regex matching, and numeric and datetime comparisons. These are capabilities that Kubernetes label selectors cannot express.

Every change is event-sourced -- nothing is overwritten, everything is recorded as an immutable event stream. The platform provides full auditability, the ability to replay and react to any change, and temporal queries across the entire history of any artifact.

The event-sourced foundation means the platform remembers everything. Agents and humans can ask not just "what is the current state?" but "what happened, when, and why?"

The MCP Server​

Agents interact with the platform through its Model Context Protocol server. The MCP server exposes all platform operations -- discovering types, creating artifacts, managing relationships, watching for changes -- through a standard tool interface. Agents authenticate via OAuth2, giving them the same identity and permission model as human users.

The tools are generic and parameterized: they work with any artifact type without requiring registration changes. When someone defines a new artifact type, it is immediately available to every agent on the platform. No code changes, no redeployment, no waiting. Agents are first-class participants, not afterthoughts bolted onto a human-only system.

What's Next​

To understand the platform's core concepts, start with How WonderForge Works. To start building, see the Working with WonderForge guides.