Declarative software for humans + agents

Give your agents the full picture.

Connect UI, APIs, tests, and extensions through explicit contracts. Give developers and agents a shared view of how your entire software works.

Start building Explore the workflow

Installation guide ↗

curl -fsSL https://axiomcore.dev/install | bash

Keep your stack. Start with one contract.

▪ ▪ ▪ app.axiom / shared application context

$ axiom build app.acore

✓ Versioned contract built

agent / understand this application

01 Interface pages · state · actions

02 Backend operations · types · policies

03 Behavior mocks · authored tests

04 Extensions inputs · effects · permissions

Reading the declared interface

ONE CONNECTED MODEL

⌗ UI intent

↔ API contract

A .axiom versioned + typed

✓ TESTS expectations

⌘ EXTENSIONS authority

Declared relationships.
Explicit boundaries.

CONTEXT YOUR AGENT CAN INSPECT

The pieces. Their connections. The rules between them.

Illustrative model · unknowns stay explicit

UI · declarative pages · state · actions

CONTRACT · typed operations · policies

TESTS · authored mocks · expectations

TARGETS · alpha web · emulators

EXTENSIONS · bounded explicit permissions

How AxiomCore helps

One contract connects the moving parts.

Start with existing code or author in Acore. A versioned contract gives clients, tests, Inspector, and coding agents a boundary they can inspect.

01 / CONNECT YOUR STACK INTERACTIVE PRODUCT WALKTHROUGHS

01 / CONNECT YOUR STACK

Your API. A shared contract. Every client.

Extract your service’s typed boundary, build an artifact, then pull it into an existing frontend. Your backend continues to handle the requests.

FastAPI + vanilla web · Available

main.py FASTAPI

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Task(BaseModel):
    id: str
    title: str
    completed: bool = False

@app.get("/tasks/{id}", response_model=Task)
def get_task(id: str):
    return Task(id=id, title="Review release notes")

terminal AXIOM CLI

# In your frontend project
axiom pull   --contract ../backend/axiom.axiom   --framework atmx-web

# Then initialize the runtime and use
# the generated target-specific client.

VERSIONED BOUNDARY

A tasks.axiom One artifact. Exact identity.

GET /tasks/{id}

id: String
title: String
completed: Boolean

PULL + LOCK →

● ● ● localhost / tasks ↗

WORKSPACE / RELEASE

Today’s focus01

IN REVIEW Review release notes

Ready for your next release.

YM Release team

CONTRACT RESPONSE { id, title, completed }

01 / Extract route and response types from the existing service.

After CLI installation and alpha access, install the FastAPI extractor. Extraction imports your application; its Python dependencies must be available. React and Flutter paths are alpha.

Client integration guide ↗

02 / BUILD WITH ACORE

One interface. Room to respond.

Describe the input, button, state, and contract call together. The same task interface adapts to a browser, Android Emulator, and iOS Simulator.

Acore UI · Alpha

main.acore ABRIDGED ACORE UI

use contract Tasks from "tasks" audience "mobile"

page Home {
  state draft: String = ""
  query tasks = Tasks.list_tasks()
  mutation create = Tasks.create_task(title: draft)

  action submit() {
    create.run()
    draft = ""
  }

  view {
    View {
      Text("Today’s focus")
      Input(value: draft, placeholder: "Add a task")
      Button(label: "Add task", on_press: submit)
      List(items: tasks.data, key: |task| task.id) {
        task => Text(task.title)
      }
    }
  }
}

WEB / RESPONSIVE PREVIEW

● ● ● ⌕ localhost:3000 / tasks ↗

9:41 ▰ ▰

WORKSPACE / MY TASKS ↗

Today’s focus

A little progress, every day.

2 tasks · Synced with your contract

$axiom run main.acore --target web

Interactive design preview using shared in-page task state. Acore excerpt adapted from the public Tasks example; loading/error branches and styles are omitted. Native runs require a configured UI Host and emulator or simulator.

Open the Acore UI example ↗

03 / TEST IN THE CONTRACT

Write the expectation. Catch the mismatch.

Declare mock responses and test cases alongside the API contract. Run against a local synthetic service—without starting your real backend or database.

Local mock + tests · Alpha

tasks.acore ENDPOINT MOCK + TEST SUITE

// tasks.acore · mock + test excerpt
mock = MockConfig {
  fallback = MockResponse {
    status = 200
    data = StaticData {
      body = { id = "task-17" title = "Release notes" }
    }
  }
}

testConfig = TestConfig {
  suites = [TestSuite {
    name = "Task contract"
    baseUrl = "http://localhost:8080"
    checks = [CheckDef {
      label = "Task response matches the contract"
      route = Routes.get_task
      pathParams = { ["id"] = "task-17" }
      expect = [
        StatusExpectation { value = 200 }
        SchemaExpectation { strict = true }
      ]
    }]
  }]
}

The declared Task schema requires completed: Boolean.

Contract test runner ILLUSTRATIVE LOCAL RUN

▣

Isolated mock data localhost:8080 · synthetic task fixture

LOCAL

TERMINAL 01 / START THE MOCK $ axiom serve tasks.acore --port 8080 TERMINAL 02 / RUN THE SUITE $ axiom test tasks.acore

Task contract / get_task READY

○ HTTP status is 200 Not run

○ Response matches Task Not run

READY TO RUN The mock is missing a required field.

Run the suite to see which expectation catches it.

The mock block belongs to an EndpointDef; the suite is declared in the same contract. CLI setup is required. Local fixtures remove the need for a real backend/database; managed Cloud sandboxes are a separate alpha workflow. This browser demo simulates the runner.

Contract testing guide ↗

04 / ANALYZE THE APPLICATION

Ask about behavior. Follow the evidence.

Explore the relationships between UI, state, contract operations, and permissions. Inspector uses semantic facts and typed edges, with source references and explicit limits.

Axiom Inspector · Alpha

AXIOM INSPECTOR tasks-workspace / illustrative snapshot DECLARED GRAPH

TRACE / DOWNSTREAM

From click to contract operation.

SELECT A NODE

SOURCE EVIDENCEComplete taskmain.acore · Button(on_press: complete)

RELATIONSHIP declared binding

The button names its action in source.

axiom inspect trace Home.complete . --direction downstreamJSON / CLI / LOCAL DASHBOARD

A normal source diff shows changed lines. Axiom’s declared application model makes cross-layer relationships queryable through one graph. Illustrative evidence here is bounded: external backend internals and undiscovered consumers remain unknown.

Explore semantic change review ↗

05 / SANDBOXED EXTENSIONS

Imperative logic. Explicit permission.

Call a typed extension from Acore. Rust, TypeScript, and Python profiles compile to Wasm; the host validates each proposed effect against effective authority.

Experimental

risk_forecast.py ABRIDGED SDK EXAMPLE

from axiom_extension_sdk import extension
from axiom_bindings import selectors

@extension.export
def assess_delivery_risk(context):
    score = min(96, context.input["blocked_tasks"] * 18)
    patch = (context.patch("ui:forecast")
        .set(selectors.ui_forecast_risk_score, score)
        .set(selectors.ui_forecast_risk_label, "Watch")
        .build())
    return context.complete(
        {"risk_score": score}, patches=[patch])

risk_forecast.rs ABRIDGED SDK EXAMPLE

use crate::axiom_bindings::ui::Forecast;
use axiom_extension_sdk::prelude::*;

// Inside #[extension] impl DeliveryRisk
#[export]
fn assess_delivery_risk(
    &mut self, invocation: TypedInvocation
) -> Result<ExtensionResponse> {
    let forecast = Forecast::from(&invocation)?;
    let input = invocation.input::<RiskInput>()?;
    let score = (input.blocked_tasks * 18).min(96);
    Ok(ExtensionResponse::new(RiskAssessment { risk_score: score })
        .patch(forecast.patch()
            .risk_score(score).risk_label("Watch")))
}

risk_forecast.ts ABRIDGED SDK EXAMPLE

import { defineExtension } from "@axiomcore/extension-sdk";
import { selectors } from "@axiomcore/extension-bindings";

export default defineExtension({
  exports: {
    assess_delivery_risk(context) {
      const score = Math.min(96,
        Number(context.input.blocked_tasks) * 18);
      return context.complete({ risk_score: score }, {
        patches: [context.patch("ui:forecast")
          .set(selectors.ui_forecast_risk_score, score)
          .set(selectors.ui_forecast_risk_label, "Watch")
          .build()],
      });
    },
  },
});

ACORE / DECLARED CONNECTION

use extension Risk from "risk"
  export "assess_delivery_risk"

AxiomDeps.toml APPLICATION GRANT

Grant write access to risk_labelChange the grant in this illustrative example.

AWAITING INVOCATION Two proposed writes. One permission.

forecast.risk_scoregranted

forecast.risk_labelmissing

Run the extension to see the host’s permission check.

Adapted from Flowspace’s public extension examples. Types and boilerplate are abridged. Missing write authority rejects the proposed patch; no partial state update is committed. A grant must also match the package request and target policy.

View full implementations ↗

06 / OBSERVE A REAL BOUNDARY

One request. A trace you can explain.

Follow an instrumented request through validation, transport, response, and cache behavior. Select an event to inspect what the runtime actually reported.

Illustrative telemetry

Request waterfall READY / NO EVENTS

DURATION —

RESPONSE —

CACHE EFFECT —

EVENT 0 ms 100 ms 200 ms

EVENT DETAILS

Complete the task to generate a simulated trace.

Demo timings, not benchmarks. Only emitted instrumentation is evidence.

Inspector describes declared behavior; observability records emitted events. This interactive trace is simulated and makes no network request. Missing instrumentation is not filled in by inference.

Telemetry and observability ↗

STARTING PATHS

Start with the part you own.

Bring an existing API, author a new Acore interface, or make a contract easier to test and inspect. Each path gives you a versioned boundary you can build on.

Keep your backend. Connect your clients.

Build a contract from a supported existing service, then consume a pinned, typed operation without replacing the backend.

Open the simple-backend example ↗

Author an Acore UI. Choose its target.

Define pages, state, actions, and contract queries in Acore. Run the authored UI for supported web, Android emulator, or iOS simulator development paths.

Distinct development targets · host behavior remains explicit · not pixel-identical output

Open the Acore UI example ↗

Make behavior testable.

Declare stateful mock behavior and author checks for the responses your app depends on—even while parts of the backend are still being built.

Mocks declare behavior. Developers author the expectations.

Open the Tasks demo runbook ↗

Give developers and agents evidence.

Ask Inspector what a button can execute, what depends on an operation, or what a contract change affects. Get a bounded answer with source evidence and known limits.

What can execute—not proof that a user performed the action.

Explore Inspector ↗

01 / Connect your backend · Scroll to explore / hover to preview

AXIOM INSPECTOR · ALPHA

Git shows the edit.
Axiom shows the impact.

A line diff is only the start. Follow what an action can do, inspect what a run reported, and review what a change means across the application.

BEFORE THE CLICK / DECLARED BEHAVIOR

See the path before you run it.

The UI names an action. The action uses a contract operation. The contract identifies the endpoint. Inspector connects those facts.

01 Complete task Button

→

02 Update task Acore action

→

03 Task service Contract operation

THE USEFUL ANSWER This button can update this task.

Each relationship has a source. External backend internals stay outside the known graph.

BEFORE YOU MERGE / SEMANTIC CHANGE REVIEW

One small edit. A much bigger question.

Git tells you which line changed. Axiom compares semantic facts, classifies compatibility or authority changes, and follows the known impact.

THE SOURCE EDIT

− completed: Boolean

Task response schema

BREAKING CHANGE Task responses lose a required field.

The old contract promised completed. Existing consumers still expect it.

Review the consumers before upgrading. Known impact is bounded. Missing consumers remain unknown.

Illustrative application / declared, observed, and changed evidence stay distinct. Explore semantic diff ↗

Bring the same evidence into CI.
Gate breaking changes and permission increases with machine-readable reports.

axiom inspect diff before.evidence.json after.evidence.json \
  --fail-on breaking,permission-increase --format json

ACORE UI · ALPHA

Write the experience.
Let the layout respond.

Pages, inputs, actions, and contract queries in one readable source. Explore the same interface across browser, Android Emulator, and iOS Simulator.

main.acore ABRIDGED ACORE UI

use contract Tasks from "tasks" audience "mobile"

page Home {
  state draft: String = ""
  query tasks = Tasks.list_tasks()
  mutation create = Tasks.create_task(title: draft)

  action submit() {
    create.run()
    draft = ""
  }

  view {
    View {
      Text("Today’s focus")
      Input(value: draft, placeholder: "Add a task")
      Button(label: "Add task", on_press: submit)
      List(items: tasks.data, key: |task| task.id) {
        task => Text(task.title)
      }
    }
  }
}

BROWSER / LIVE DESIGN PREVIEW

● ● ● ⌕ localhost:3000 / tasks ↗

9:41 ▰ ▰

WORKSPACE / MY TASKS ↗

Today’s focus

A little progress, every day.

2 tasks · shared preview state

$axiom run main.acore --target web

Interactive design preview. Add a task, then switch targets: your preview state stays with you. Run the Acore UI example ↗

Abridged Acore source. Development targets have distinct hosts and capability checks; native runs require a configured UI Host and emulator or simulator.

THE AXIOMCORE COMMUNITY Coming soon

Build once.
Give others a head start.

A reusable foundation for APIs, services, component libraries, themes, and database schemas. Build your own contract and share it through the public community Marketplace.

ONE PACKAGE FORMAT .axiom MANY BUILDING BLOCKS

Your application Selected version · verified artifact · committed lock

↵

TERMINAL / USE A CONTRACT

API & SERVICE CONTRACT

A typed boundary, ready to connect.

Pull a versioned service contract into the frontend you already use.

PROPOSED MARKETPLACE CLI / EXAMPLE PACKAGE

THE PART YOU CAN TRUST

Version Pinned

Artifact Exact bytes

Upgrade Semantic review

AXIOM DASHBOARD · ALPHA

Your team moves independently.
Your contracts stay in sync.

Log in, link a project, and publish immutable signed contracts. Review changes asynchronously in Axiom Dashboard; developers and agents can pull the exact version their application needs.

01 / CONNECT YOUR WORKSPACE

Your local project meets your team.

Authenticate the CLI and link this directory to a project. Project membership determines who can read, publish, and activate releases.

AXIOM CLI

axiom login
axiom project link

Explore Axiom Dashboard ↗

Connected workflows require an account, membership, and a reachable control plane. Contract releases are separate from application deployment.

A Axiom Dashboard Workspace / Release team RT

PROJECT / TASKS

Tasks API

PROJECT LINKED

CONTRACT RELEASE tasks.axiom 1.2.0

Versioned artifact

Identity Immutable version

Provenance Signed at release

Review Semantic evidence

TEAM ACTIVITY / ILLUSTRATIVE

Project linked Your CLI workspace is connected.

Backend maintainer publishes 1.2.0 Immutable artifact + release signature.

Reviewer discusses a semantic change Context stays with the release comparison.

Frontend developer or agent pulls 1.2.0 The application pins the reviewed version.

Choose your starting point

Start with your code. Make the boundary clear.

Keep an existing backend or author a new Acore UI. Build and test locally, inspect the contract, and share a reviewed version when you’re ready.

Connect an existing API Build with Acore

Explore runnable examples

Give your agents the full picture.

One contract connects the moving parts.

Your API. A shared contract. Every client.

Today’s focus01

One interface. Room to respond.

Today’s focus

Write the expectation. Catch the mismatch.

Ask about behavior. Follow the evidence.

From click to contract operation.

Imperative logic. Explicit permission.

One request. A trace you can explain.

Start with the part you own.

Keep your backend. Connect your clients.

Author an Acore UI. Choose its target.

Make behavior testable.

Give developers and agents evidence.

Git shows the edit.
Axiom shows the impact.

See the path before you run it.

Follow one request all the way back.

One small edit. A much bigger question.

Write the experience.
Let the layout respond.

Today’s focus

Build once.
Give others a head start.

A typed boundary, ready to connect.

Your next building block could be someone else’s starting point.

Your team moves independently.
Your contracts stay in sync.

Your local project meets your team.

Tasks API

Start with your code. Make the boundary clear.