Features — XetoBase

🤖

AI Agent

Wooley AI Agent

Your AI, Your Rules

Wooley is your personalized AI agent built directly into XetoBase. It understands your data model, your xeto.dev specs, and your workflows — so it can answer real questions about your real data.

Ask Wooley to write an Axon script, query records by natural language, explain a spec from the xeto.dev registry, or scaffold a new ION UI component. Wooley operates inside the sandboxed Axon runtime, so there are no security concerns about AI-generated code running loose.

Wooley is also customizable — you can give it context, restrict its scope to specific data namespaces, and build your own agent personas on top of it. It's the intelligence layer of your stack.

Natural language queries over your XetoBase records
Axon code generation and explanation
xeto.dev spec lookup and interpretation
ION component scaffolding
Observable workflow creation
Fully sandboxed — AI-generated code runs in Axon
Customizable persona and data scope

Calling Wooley from Axon

// Ask Wooley from inside an Axon script
result = wooley("Summarize all high-temp alerts from this week")

// Wooley returns structured data
{
  summary: result->summary,
  count:   result->count,
  sites:   result->sites
}

// You can also pass context
wooley({
  prompt: "Create a dashboard for this dataset",
  context: readAll(SiteReading),
  format: "ionComponent"
})

Wooley Chat (inline)

You

What xeto.dev spec should I use for storing weather readings?

Wooley

I'd recommend ph::WeatherStation from the Project Haystack library on xeto.dev. It includes temp, humidity, and pressure slots already typed. Want me to scaffold a record using it?

🎨

UI Framework

ION UI Framework

Build UIs without limits.

ION is XetoBase's built-in UI framework. It ships with a library of pre-built apps and components that connect directly to your live data — no API wiring required. Build anything from a simple data form to a multi-page web application.

The drag-and-drop builder makes it approachable for non-developers, while the underlying ION component model is fully programmable via Axon for advanced customization.

Web Apps

Multi-page app builder
Form generation from xeto specs
Routing and navigation
Publish as a public site

Dashboards

Live data charts and gauges
Configurable widget library
Auto-refresh and streaming
Embed in existing pages

Drag & Drop Tools

Figma-style canvas editor
Excel-style data grid
Presentation builder
Task management boards

Built-in Components

Tables, forms, charts
Map and geo views
Timeline and calendar
AI chat widget (Wooley)

ION Component Example Axon

// Define an ION dashboard widget
ionWidget({
  type: "barChart",
  title: "Temp by Site",
  data: readAll(SiteReading)
    .filter(r => r->ts > today()),
  xAxis: "site",
  yAxis: "temp",
  color: "#10b981"
})

Framework Highlights

Zero external dependencies — all runs inside XetoBase
Real-time data binding via Observable hooks
Dark and light theme support out of the box
Fully responsive — mobile-first component library
Export to static HTML or embed as widget

⚡

Scripting Language

Axon Language

Vibe code. No fear.

Axon is XetoBase's sandboxed functional scripting language. It's designed to be simple enough to write on the fly, powerful enough to build production workflows, and safe enough to let Wooley AI generate code that runs directly in your environment.

The Axon runtime is fully sandboxed — it can't access the filesystem, make arbitrary network calls, or escape its execution context. This means you can let AI write Axon without worrying about what it might do. The enterprise security posture is built into the runtime itself.

Axon runs on both client and server. Write the same logic once and decide at runtime where it executes. It's the single language for queries, UI logic, Observable triggers, and AI function calls.

Functional, expression-based syntax — easy to learn
Runs on client or server — same code, your choice
Fully sandboxed — no filesystem, no arbitrary I/O
AI-safe — Wooley can generate and run Axon safely
Used for queries, UI logic, and Observable triggers
Rich standard library: math, strings, dates, sets, grids
Interop with xeto.dev type specs at runtime

Axon examples

Reading records

// Read all SiteReading records from today
readAll(SiteReading)
  .filter(r => r->ts >= today())
  .sortBy("temp", "desc")
  .limit(100)

Observable trigger

// Fire when a new record is saved with high temp
newRecord => {
  site:  newRecord->site,
  alert: if (newRecord->temp > 80)
           "High temp!"
         else
           "OK",
  ts:    now()
}

Calling Wooley

// Ask Wooley to explain a spec
wooley({
  prompt:  "Explain the ph::Site spec",
  format:  "markdown"
})

// Generate a UI component
wooley({
  prompt:  "Build a form for SiteReading",
  format:  "ionComponent"
})

🔄

Event Framework

Observable Framework

React to everything.

The Observable framework is XetoBase's event-driven workflow engine. Define triggers that fire automatically when records are created, updated, or deleted — then write the response logic in Axon.

Observables are the connective tissue of your stack. Use them to validate incoming data, fan out notifications, transform records, call external APIs, update derived records, or kick off Wooley AI workflows — all without polling.

Every Observable runs inside the Axon sandbox, so there's no worry about a runaway trigger taking down your environment. They're also versioned, audited, and testable inline.

onCreate Fires when a new record matching the spec is saved

onUpdate Fires when an existing record is modified

onDelete Fires before a record is removed from the store

onSchedule Time-based trigger — cron-style or interval

onCondition Fires when a field crosses a threshold or expression

Observable examples

onCreate trigger

// Validate and enrich on create
observe(SiteReading, "onCreate", rec => {
  if (rec->temp > 80) {
    notify("ops-team", {
      msg:  "High temp at " + rec->site,
      data: rec
    })
  }
  rec.set("verified", true)
})

onUpdate with Wooley

// Ask Wooley when records change
observe(Project, "onUpdate", rec => {
  summary = wooley({
    prompt: "Summarize changes to this project",
    context: rec
  })
  rec.set("aiSummary", summary)
})

onSchedule trigger

// Run a daily rollup at midnight
observe(SiteReading, "onSchedule", {
  cron: "0 0 * * *",
  fn: () => {
    rollup = readAll(SiteReading)
      .filter(r => r->ts >= yesterday())
      .aggregate("temp", "avg")
    create(DailyRollup, rollup)
  }
})

🗄️

Data Store

Data & CMS

Your data, perfectly typed.

XetoBase is a CMS-style data store where every record is validated against a Xeto type spec. Think of it as a database with a schema registry built in — but instead of writing migrations, you point at a spec from the xeto.dev library ecosystem.

Xeto specs work like NPM packages for data types. Find a spec for Building Automation, Science, Finance, or any domain — or define your own and publish it. Your records are always typed, always validated, and always shareable with anyone using the same spec.

The store supports hierarchical namespaces, file attachments, relationship links, and full-text search — all accessible via Axon or the REST API.

CMS-style record management with type validation
Backed by xeto.dev spec registry (like NPM for types)
Hierarchical namespaces and record relationships
Full-text and structured search via Axon
File and binary attachment support
Schema-less flexibility with spec-enforced structure
Version history and audit trail on every record

Xeto-validated record

// A SiteReading record validated against ph::SiteReading
{
  _spec: "ph::SiteReading",
  site:  "Building-A-Floor-3",
  temp:  73.4,
  unit:  "°F",
  ts:    "2025-03-18T14:22:00Z",
  sensor:"sensor-042",
  tags: ["hvac", "zone-3"]
}

// Create it via Axon — validation is automatic
create(SiteReading, {
  site: "Building-A-Floor-3",
  temp: 73.4,
  ts:   now()
})

Supported Spec Libraries

Project Haystack (Building Automation)
oBIX / ASHRAE (HVAC, Energy)
Science & engineering units
Custom org-specific specs
Browse all libraries →

🔒

Security

Enterprise-ready by default.

XetoBase is built with enterprise security as a first-class requirement — not an afterthought. Every layer of the stack, from the Axon sandbox to the data store to the network layer, is designed to be secure out of the box.

Deploy on-premises inside your existing network infrastructure, or run in a completely air-gapped environment with zero external connectivity required. XetoBase was designed for organizations where data sovereignty is non-negotiable.

On-premises deployment — runs on your infrastructure
Air-gapped support — zero required external connectivity
End-to-end encryption for data in transit and at rest
Role-based access control (RBAC) on records and namespaces
Full audit logging — every read, write, and delete
Axon sandbox — AI and user scripts cannot escape runtime
SSO / SAML / OIDC integration
Signed spec verification via xeto.dev registry
SOC 2 Type II readiness (coming soon)

🏢

On-Prem

Deploy inside your own network. No cloud required.

✈️

Air-Gap

Fully disconnected deployments supported.

🔑

RBAC

Fine-grained access control on every record.

📋

Audit Log

Every action is logged and queryable via Axon.

🔐

Encryption

Data encrypted at rest and in transit by default.

🛡️

Sandbox

Axon runtime prevents code escaping its context.

Everything you need.
Nothing you don't.

Wooley AI Agent

ION UI Framework

Web Apps

Dashboards

Drag & Drop Tools

Built-in Components

Framework Highlights

Axon Language

Observable Framework

Data & CMS

Supported Spec Libraries

Security

On-Prem

Air-Gap

RBAC

Audit Log

Encryption

Sandbox

Ready to try XetoBase?

Everything you need.Nothing you don't.

Wooley AI Agent

ION UI Framework

Web Apps

Dashboards

Drag & Drop Tools

Built-in Components

Framework Highlights

Axon Language

Observable Framework

Data & CMS

Supported Spec Libraries

Security

On-Prem

Air-Gap

RBAC

Audit Log

Encryption

Sandbox

Ready to try XetoBase?

Everything you need.
Nothing you don't.