machina

Early access · invite required

machina · v0.1 · open-core

A typed knowledge graph for agents and humans.

One typed graph under everything you capture — people, places, events, actions, intentions — exposed natively over MCP. The apps are built on it. Capture is free-form; structure is optional, monotonic, never destructive. Agents propose. You confirm.

Run the engine See the capture loop Open-core · self-host when the engine opens

The capture loop, trust gate, and kind recipes below ship today in loam for iOS — the app this page demos.

Capture shapes

  • Note
  • Asset
  • Person
  • Place
  • Event

Translate out

  • Calendar
  • Reminders
  • Obsidian

MCP-compatible · Claude Code · Cline · Continue

01 · capture

Type a sentence. Get a graph.

No vocabulary tax at capture. Every line lands as one CoreNode — the engine extracts entities, proposes a kind, and surfaces the result where you will act on it. Run a capture below.

pick a capture

Demo: a free-form capture line becomes a typed graph. "Lunch with Maya at Terra on Fri 1pm" extracts an Event with schedulable.end_at fri 13:00, a suggested has_member edge to Person Maya, and a suggested located edge to Place Terra, then surfaces as a stream card with two suggestions pending. "Kyoto Oct 12–17, ryokan near Gion" extracts an Event with schedulable.start_at oct 12, suggested located edges to Place Kyoto and Place Gion, and an Oct 12–17 date chip. "Alexander — The Timeless Way of Building" lands as a Note with kind candidate Reading (progress + linked) and a suggested authored edge to Person Alexander.

Extraction lands as suggested, never as fact. No form, no folder, no type picker — and nothing above changed the original capture.

02 · composition

Every app prescribes its types. Machina prescribes none.

A reminders app prescribes reminders; a notes app, notes; a database, its column types. Here kinds are trait recipes stored as data — yours to define and rewrite. A Reading is linked + progress; a Trip is located + schedulable. There is no Task type — a todo is one recipe among many. Pick a kind, or flip the bits yourself.

01 · pick kind gallery
02 · declare trait bits
→ due chip
→ state control
→ priority flag
→ estimate chip
→ place chip
→ external ref
→ attachment count
03 · render one corenode
corenode · n_4e19 SUN

The Timeless Way of Building

P1 ~45m Library openlibrary.org/… PDF

kind: reading · traits: progress + linked

Six kinds, seven trait bits, one CoreNode. None of them is compiled in — each is a recipe you own. A Trip and an Errand differ by two bits, not by two apps. When a kind grows a trait, cards pick up the chrome automatically — no new UI per type, no migration.

03 · through-line

One primitive, three surfaces, same shape.

A Paper is the same typed node whether an agent reads it over MCP, a human opens a workbench card, or a walk traverses the graph. No translation layer, no parallel models.

a · agent mcp
> read_node { "id": "p_8f3a" }

{
  "id": "p_8f3a",
  "core_kind": "note",
  "kind_def": "kind_def::paper",
  "props": {
    "title": "Out of the Tar Pit",
    "doi": "10.1.1.93.8928",
    "venue": "SPA 2006",
    "published_at": "2006-02-06"
  }
}

// cites edges → p_2b71, p_4c09
//   (walk_from, depth 1)
b · human workbench
p_8f3a paper · researcher pack

Out of the Tar Pit.

doi
10.1.1.93.8928
venue
SPA 2006
cites
p_2b71, p_4c09
c · query graph walk
GET /v1/walk?from=p_8f3a&depth=2

{
  "from": "p_8f3a",
  "depth": 2,
  "steps": [
    {
      "depth": 1,
      "edge": { "kind": "cites",
                "to": "p_2b71" },
      "vertex": { "id": "p_2b71" }
    }
  ]
}

// walk_from over MCP hits the same
//   traversal — a typed subgraph,
//   not a similarity blob.

Same ID. Same fields. Same edges. RAG retrieves chunks; a document store recalls pages; Machina returns a typed subgraph the agent can plan against.

04 · trust

Agents propose. You confirm.

Every edge an agent writes lands as suggested, carrying provenance and a rationale. Confirmation is a human act — the repository refuses an agent-written confirmed. Work the queue below; both outcomes are recorded.

suggested · 3
  • p_8f3a —cites→ p_2b71

    source: agent · confidence 0.82

    “The introduction quotes p_2b71's central claim verbatim.”

    status: dismissed — kept, not deleted

  • n_2c41 —tagged→ Tag { reading }

    source: heuristic · confidence 0.64

    “Title matches three nodes already tagged reading.”

    status: dismissed — kept, not deleted

  • e_77 —has_member→ Person { Maya }

    source: agent · confidence 0.91

    “Extracted from the capture text 'lunch with Maya'.”

    status: dismissed — kept, not deleted

confirmed · 0
  • p_8f3a —cites→ p_2b71

    status: confirmed · source: human

  • n_2c41 —tagged→ Tag { reading }

    status: confirmed · source: human

  • e_77 —has_member→ Person { Maya }

    status: confirmed · source: human

EdgeStatus: Confirmed | Suggested | Dismissed — enforced in the repository layer, not by prompt. An agent structurally cannot write a confirmed fact.

05 · orchestration

Ingest anywhere. Review once. Translate out.

loam is the native orchestration surface on iOS. Composer, share sheet, clipper, photo import, and device import (calendar, contacts, reminders) all land in one review loop; translators push confirmed nodes out to the services you already live in. The engine stays the source of truth.

engine (SSOT) translator registry
  • Calendar
  • Reminders
  • Obsidian · Files
  • Notion — in design
machina shape
external representation
Event + schedulable
Calendar — EKEvent; attendees from has_member edges
schedulable + progress
Reminders — EKReminder; completed = is_done
Note / Page body
Obsidian / Files — markdown; body round-trips
KindSchema
Notion — database per kind; fields → properties (in design — today Notion ships as an importer)

External refs live on the linked trait — the mapping is itself graph data, visible on the node. Anything an integration writes back enters as suggested, reviewed like any other ingest. Orchestration never bypasses the trust model.

06 · one graph

One graph. Agents and surfaces.

Agents and humans work against the same typed graph — not copies that drift. Agents come in over MCP, an open protocol: any client that speaks it reaches the same nodes Claude does. Human surfaces get projections, pushed out by translators; your own edits in a surface apply directly, and agent and import proposals enter as suggested.

01 · agents read
  • machina-mcp the graph over MCP — Claude Code, Cline, Continue, any client that speaks the protocol ships
  • Siri Shortcuts open capture in the iOS app today; App Entities for querying nodes are stubbed ships
  • agent writes will land as suggested, behind the same trust gate humans confirm in in design
02 · surfaces projections
  • Obsidian · Files markdown vault export to a folder you choose ships
  • Reminders two-way — schedulable + progress nodes round-trip ships
  • Calendar two-way — Event nodes round-trip; Calendar-app edits flow back ships
  • Contacts import — people land as Person nodes; connections arrive as suggested ships
  • Notion database per kind; fields map to properties in design

No second store. A vault file or a reminder is a projection of a node, not a fork of it; your own edits apply directly, and agent proposals enter as suggested for review. What ships is labeled ships; what’s in design says so.

07 · apps

One engine. The apps built on it.

The engine is the shared substrate; every app reads and writes the same typed graph, not a copy that drifts. loam ships today on iOS — the capture loop, trust ladder, and kind recipes above run on it. The clipper and the web workbench ship alongside it; the machina workbench is direction.

loam iOS ships

The native capture surface, and the app this page demos. Free-form capture, confirm-before-write, and a trust ladder the agent earns rung by rung — the loop the sections above simulate.

  • NL capture + share sheet
  • event capture, confirm-before-write
  • task cards + lenses
  • trust ladder L0–L3, earned
  • pack install / fork / uninstall
  • Reminders-style kind editor
  • two-way Calendar + Reminders
  • Contacts import
  • markdown vault export
  • Live Activities
loam-clipper browser ships

Chrome, Firefox, and Safari extension — capture a page or a selection straight into the graph from the web.

workbench web ships

SolidJS multi-page app — Browse, Dashboard + editor, Inbox, Kind editor, Library. Where Page and Dashboard projections live.

machina direction in design

The rich workbench the family feeds toward. Design-stage — the exploration currently lives as design docs, not code.

No app owns the data. Each is a surface over the one engine — what ships is labeled ships; the machina workbench is in design and says so.

08 · quickstart when the engine opens

Wire it into your agent in three lines.

Self-host the engine, install the MCP server, point your client at it — with Claude Code, Cline, Continue, or any MCP-compatible runner. The engine image and the machina-mcp crate below aren’t published yet; this is the shape self-hosting takes when the open-core split lands, not a command to run today.

  1. 01 · engine docker
    # pull and run the engine
    docker run -d \
      --name machina \
      -p 8080:8080 \
      ghcr.io/machina/engine:latest
    
    # verify
    curl localhost:8080/admin/health
    # {"db":"ok"}
  2. 02 · mcp server cargo
    # install the MCP bridge
    cargo install machina-mcp
    
    # point it at the local engine
    export MACHINA_ENGINE_URL=\
      http://localhost:8080
    
    machina-mcp --version
    # machina-mcp 0.1.0
  3. 03 · client mcp.json
    {
      "mcpServers": {
        "machina": {
          "command": "machina-mcp",
          "env": {
            "MACHINA_ENGINE_URL":
              "http://localhost:8080"
          }
        }
      }
    }

Once it opens, the JSON drops into ~/.config/claude/mcp.json, ~/.cline/mcp.json, or your client's equivalent. Restart the agent, and the machina tools (list_note, read_node, walk_from, …) appear in the next session.

09 · structure

Open engine. Hosted coordination.

The substrate opens under GPL-3.0 and is built to self-host. The orchestration on top is hosted, paid, and ours to evolve. Two halves of the same product, deliberately separated.

01 · b-spine open

Open engine.

Rust core, opening under GPL-3.0. Self-host the engine plus MCP server in one Docker command once it lands. Every capture is a CoreNode; every fact is a typed edge. Compatible with any MCP client. The contract it exposes — the typed node/edge/kind schema plus the MCP tool surface — is named Kindgraph, versioned separately from the engine so anyone can implement it without adopting the engine.

  • · machina-domain — CoreNode, typed edges, kinds, trust rungs — the Kindgraph contract every client compiles against
  • · machina-mcp — thin MCP server over the graph; no AI logic inside
  • · machina-db / machina-db-local / machina-sync-relay — server store, on-device store (opens after the crypto audit), encrypted sync relay
  • · machina-providers — external ingest: Notion-export import, URL metadata — commodity connectors, open
  • · machina-authkit — bearer-token + rate-limit leaf the sync relay builds on
02 · a-surface hosted + on-device

Hosted coordination.

The layer that turns the engine into an autonomous workbench. What ships today is the understanding pipeline; the coordination plane above it is direction, and is labeled as such.

  • · machina-ai — NL→Event parsing, suggest-on-capture, embeddings, provider routing
  • · direction — learned tool routing, trace consolidation, goal planning; in design, not yet crates

Billing meters coordination calls, not engine calls. Reads, writes, and traversals against the engine stay free.

Linear meets Are.na meets a planning room.
Calm. Deliberate. Instrumented.

10 · vocabulary

Kinds are data. Vocabularies install.

No kind on this page is compiled in. The engine seeds five ontology packs — named bundles of kinds and relations you browse, preview, and install. Installs are idempotent; a pack never overwrites a kind you already own.

bare seeded

Nothing but the capture core. Grow kinds as patterns emerge.

  • Page

browse · preview · install

founder seeded

Startup-operator vocabulary, dream to module.

  • Mission
  • Market
  • Project
  • Protocol
  • and more kinds

browse · preview · install

student seeded

A term's worth of structure.

  • Course
  • Lecture
  • Assignment

browse · preview · install

researcher seeded

Papers and the edges between them — cites, refutes.

  • Paper
  • Author
  • Experiment
  • Claim
  • Dataset

browse · preview · install

collector seeded

Objects, where they came from, where they live.

  • Item
  • Collection
  • Acquisition

browse · preview · install

your-pack unwritten

A pack is rows in the graph, not a plugin. The next vocabulary on this shelf doesn't have to be ours.

publish · someday

The install mechanism ships today — browse, preview, idempotent install. A public shelf of packs other people publish is the direction, not a feature; nothing about it needs a recompile.

11 · pricing

Free to self-host. Paid to coordinate.

The engine opens under GPL-3.0 and stays that way. Coordination plans cover the hosted control plane — multi-agent planning, learned routing, memory consolidation, and run-trace history.

self-host when it opens

$0

your hardware, your data

The engine plus MCP server, GPL-3.0, when the open-core split lands. One Docker command, no account, no telemetry.

  • · full primitive set + graph walk API (/v1/walk)
  • · MCP server for any client
  • · community support, GitHub issues
solo coming soon

$8/mo

billed annually · $10 monthly

Hosted coordination for one human. Run-trace history, learned routing, and the workbench, without standing up infrastructure.

  • · everything in self-host
  • · hosted engine + workbench
  • · memory consolidation, learned routing
team coming soon

$14/seat

min 3 seats · shared graph

Multi-human, multi-agent. Shared workspaces, run-trace replay across the team, SSO, audit log.

  • · everything in solo
  • · shared workspaces, role-based access
  • · SSO, audit log, priority support

Prices indicative until the hosted plane opens. No card up front; no auto-conversion from free. A Pro tier sits between Solo and Team, and Enterprise beyond — full grid when the hosted plane opens.