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.
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.
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.
The Timeless Way of Building
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.
> 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) Out of the Tar Pit.
- doi
- 10.1.1.93.8928
- venue
- SPA 2006
- cites
- p_2b71, p_4c09
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.
-
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
-
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.
- 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.
- 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
- 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.
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
Chrome, Firefox, and Safari extension — capture a page or a selection straight into the graph from the web.
SolidJS multi-page app — Browse, Dashboard + editor, Inbox, Kind editor, Library. Where Page and Dashboard projections live.
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.
-
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"} -
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 -
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.
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
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.
Nothing but the capture core. Grow kinds as patterns emerge.
- Page
browse · preview · install
Startup-operator vocabulary, dream to module.
- Mission
- Market
- Project
- Protocol
- and more kinds
browse · preview · install
A term's worth of structure.
- Course
- Lecture
- Assignment
browse · preview · install
Papers and the edges between them — cites, refutes.
- Paper
- Author
- Experiment
- Claim
- Dataset
browse · preview · install
Objects, where they came from, where they live.
- Item
- Collection
- Acquisition
browse · preview · install
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.
$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
$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
$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.