Data model
The data-model layer of the self-hosted stack.
The data-model primitive of the stack, run inside your perimeter. Declare what should exist as versioned source; agents write it as source, humans edit it as a spreadsheet. Plan, apply, drift-detect — all against state that stays in your tenancy.
Cast is a primitive of the Visca stack — it ships with the stack, versions with the stack, and audits with the stack. It is not separately purchasable.
What it is
Cast is the declarative primitive of the stack. Describe what should exist — object types, fields, relations, views, workflows, roles, permissions, applications — in versioned source. Cast diffs against current state and reconciles safely, in dependency order. Two surfaces, one substrate: coding agents author Cast as source; humans edit the same state in a spreadsheet view — object types are sheets, fields are columns, records are rows, relations are typed cells. Both write to one truth, inside your own walls, under the same Sigil identity and recorded to the same Chronicle as every other layer.
The problem
Data models are defined imperatively, in pieces — object types in one console, fields in a UI, relations in a third tool, workflows in a fourth, each a separate vendor or project. Humans get a UI, agents get nothing, neither sees the same truth. State drifts the moment it runs. No review, no diff, no rollback, no single source for what should exist — and the schema that defines your most sensitive data ends up living in someone else's cloud.
Capabilities
Two surfaces, one model
# What a coding agent sees — Cast source
# (mirrors sheets' ObjectMetadata, FieldMetadata, ViewEntity 1:1)
object "task" {
label_singular = "Task"
label_plural = "Tasks"
icon = "IconCheckbox"
is_searchable = true
label_identifier = field.task.title
}
field "title" {
object = object.task
type = "TEXT"
label = "Title"
icon = "IconNotes"
}
field "status" {
object = object.task
type = "SELECT"
label = "Status"
default_value = "TODO"
options = [
{ value = "TODO", label = "To do", color = "sky" },
{ value = "IN_PROGRESS", label = "In progress", color = "purple" },
{ value = "DONE", label = "Done", color = "green" },
]
}
field "assignee" {
object = object.task
type = "RELATION"
label = "Assignee"
icon = "IconUserCircle"
relation = {
type = "MANY_TO_ONE"
target_object = object.organizationMember
target_field = "assignedTasks"
on_delete = "SET_NULL"
}
}
view "byStatus" {
object = object.task
type = "KANBAN"
name = "By Status"
main_group_by_field = field.task.status
}
# What a human sees — the same model, in a sheet
│ title │ status │ assignee │
───────────────────────────────────────────────────────
│ Wire up Cast parser │ IN_PROGRESS │ @sasha │
│ Drift detector design │ TODO │ @rajan │
│ Bundle signer review │ DONE │ @priya │Open and commercial
Cast has two surfaces: an open-source reference in Lattice Runtime (MPL 2.0), and a managed delivery as part of the Visca stack on Visca Cloud. Features in the open never move behind the paywall.
Open
MPL 2.0 · self-hostable · foundation-track governance
Commercial
Your tenancy · dedicated · self-managed · air-gapped
LIFECYCLE · same plane
The packaging layer of the self-hosted stack.
The packaging primitive of the stack, run inside your perimeter. Immutable, content-addressed, Sigil-signed bundles — everything an autonomous actor needs to execute, packaged as a single attestable artifact and registered in your own registry.
The open-source runtime layer — and the foundation the whole stack runs on.
The runtime layer of the stack, and its open-source foundation (MPL 2.0). Runs autonomous workloads across cloud, edge, on-device, and on-robot — with first-class awareness of tokens, models, memory, and embodiment, routing over open-weight models so cognition stays in your walls.
The build surface — for humans and agents.
Where humans and agents build autonomous systems. CLI, SDKs, local runtime, eval harness, replay, documentation, templates — and an agent-facing surface so agents can author, evaluate, and ship other agents.
Across the stack
The identity layer of the self-hosted stack.
The identity primitive of the stack, run inside your perimeter. Issues, verifies, and revokes the cryptographic identity every autonomous actor holds — bound to principal, runtime, and lineage from the moment of instantiation. The one identity every other primitive trusts.
The authority layer of the self-hosted stack.
The authority primitive of the stack, run inside your perimeter. Brokers every access from an autonomous actor to a consequential resource against its Sigil — identity-bound, scoped, time-limited, and recorded to Chronicle. Long-lived credentials disappear.
The fabric layer of the self-hosted stack.
The fabric primitive of the stack, run inside your perimeter. Discovery, mTLS, and routing across every autonomous actor and every resource an actor reaches — rooted in the same Sigil identities, not hardcoded URLs, and never crossing your boundary.
The record layer of the self-hosted stack.
The record primitive of the stack, run inside your perimeter. The one audit trail every other primitive writes to — a queryable knowledge graph of every actor, plus the append-only, cryptographically chained log of every action, keyed to Sigil and Capability Grant.
The whole stack. Self-hosted. One ecosystem.
Models, identity, tools, voice, payments, runtime, and audit — as one integrated ecosystem, self-hosted, sovereign, air-gapped. Nothing stitched from vendors. Nothing leaves your perimeter. Open at the core. No license rug-pulls, ever.