Intent-driven computing

Intelligence is becoming
a computing primitive.

The first platform built around it.

Describe what intelligence should do. mashin handles execution, deployment, and governance automatically.

Traditional AI

Prompts

Models

Tools

Workflows

State

Policies

Deployment

Operations

mashin

Intent

Machine

Running everywhere

30 lines of intent. Instead of 2,000 lines of orchestration.

Every major advance in computing moved software closer to human meaning.

Intent-driven computing is the next step.

Technology What developers stopped thinking about
LanguagesHow the processor executes
Operating systemsHow resources are managed
DatabasesHow consistency is maintained
SQLHow data is retrieved
ReactHow interfaces update
CloudHow infrastructure is provisioned
KubernetesHow applications are deployed
mashin How intelligence is implemented

Machine code described execution.

Languages described algorithms.

Operating systems described processes.

Databases described relationships.

SQL described queries.

React described interfaces.

Cloud described services.

Kubernetes described deployments.

mashin describes intent.

Each abstraction absorbed the layer below it. mashin absorbs intelligent system implementation.

Intelligence should be a first-class computing primitive, not a library bolted onto existing software.

A higher level of abstraction for intelligence.

Traditional software

Developers describe:

  • Functions
  • Workflows
  • APIs
  • Retries
  • Infrastructure
  • Deployment

"How should it happen?"

Intent-driven computing

Developers describe:

  • Desired behavior
  • Goals
  • Constraints
  • Approvals
  • Boundaries

"What should happen?"

Intent is to intelligent systems what SQL was to databases. A higher-level abstraction that lets developers focus on meaning instead of implementation.

The benefits of intent-driven computing.

Less orchestration

Stop wiring together prompts, tools, retries, and workflows. Describe behavior. The platform handles execution.

Portable intelligence

Claude today. GPT tomorrow. Apple next year. Your machines remain unchanged.

Universal deployment

The same machine becomes an API, page, Siri command, MCP tool, schedule, webhook, and app surface. Without rewriting.

Understandable systems

Intent is visible. Execution is replayable. Behavior is inspectable.

Governable systems

Governance becomes possible because intent is structured. Trust emerges from architecture. Not policy.

Build once. Deploy everywhere.

One artifact. Many surfaces. Zero deployment code.

machine morning_brief "Morning Brief"

  achieves
    goal prepare_day
      succeeds when summary != null and priorities != null

  accepts
    focus as text

  responds with
    summary as text
    priorities as text
    calendar_prep as text

  ensures
    permissions
      allowed to
        read_email, read_calendar
      requires approval for
        send_message

  implements
    remember yesterday
      recall "yesterday's priorities"

    ask scan_inbox, using: "claude-sonnet"
      with role
        "You are a personal assistant who reads email and calendar."
      with task
        "Review today's calendar and recent emails. Focus area: ${input.focus}.
         Summarize what needs attention, list priorities, and prepare
         talking points for the first meeting."
      returns
        summary as text
        priorities as text
        calendar_prep as text

    compute compare
      {
        carried_over: yesterday.priorities.filter(p => !scan_inbox.priorities.includes(p)),
        new_today: scan_inbox.priorities.filter(p => !yesterday.priorities.includes(p))
      }

    decide urgency
      when scan_inbox.priorities contains "urgent"
        then "escalate"
      otherwise
        then "brief"

    remember today
      store scan_inbox.priorities as "yesterday's priorities"

  expresses
    api "/brief"
    shortcut "Morning brief"
    schedule "weekdays at 7:30am"

API

HTTP endpoint

Page

Auto-generated

Webhook

Incoming events

MCP

Any AI agent

Shortcut

Siri / voice

Schedule

Cron / interval

App

Native surface

Your intelligence. Your choice.

Most AI platforms require their cloud. mashin runs wherever you choose. The same machine. The same runtime. The same behavior. Everywhere.

Personal

Laptop

Desktop

Phone

Mac Mini

Private Infrastructure

VPS

Home Server

DigitalOcean

Hetzner

Enterprise

Private Cloud

On-Premises

Air-Gapped

AWS / Azure

Managed

mashin.cloud

Zero setup

Automatic scaling

Global edge

No black boxes.

Replay any execution. Inspect every decision. Understand exactly what happened.

Execution replay

Kine shows every step, every governance decision, every model call. Drill into sub-machines. Compare runs.

Behavioral ledger

Append-only, hash-chained. Every action recorded with cost, latency, and token usage. Queryable via SQL.

Cost tracking

Know exactly what every machine costs per run, per step, per model. Budget limits halt execution before overspend.

Trust built into the architecture.

Governed

Every action evaluated before execution.

Recorded

Every action preserved in the behavioral ledger.

Replayable

Every action can be inspected after the fact.

Traditional AI asks you to trust outcomes. mashin lets you verify them.

Everything required to build, deploy, and operate intelligence.

mashinTalk

Intent language

kore

Governance kernel

kortex

Networking fabric

cells

Deployment architecture

koda

Ambient intelligence

kine

Execution inspector

kura

Artifact registry

kanon

Lineage and provenance

kanvas

Universal surface generation

kodex

Text-first rendering surface

Formally verified governance.

572

Machine-checked theorems

41

Formal modules

0

Admitted proofs

Every governance decision executes through verified code. The proofs are public. The implementation is auditable.

A new computing model for intelligent systems.

Programming languages were built around instructions.

Databases were built around data.

The web was built around documents.

Cloud platforms were built around services.

mashin is built around intent.

We believe intent is the right level of abstraction for intelligence. Everything else follows from that decision.

Coding is writing at the level where the computer thinks.

mashin is writing at the level where you think.

Build your first machine.

Join the developer preview and help shape the future of intent-driven computing.

No spam. Just the launch announcement and occasional research updates.