Metadata-Version: 2.4
Name: manifold-ai
Version: 2.0.3
Summary: Manifold: nodes publish one value each; agents read it as text, people see it as a picture; your machines share it.
License-Expression: Apache-2.0
Project-URL: Homepage, https://github.com/Manifold-agents/manifold
Project-URL: Repository, https://github.com/Manifold-agents/manifold
Project-URL: Issues, https://github.com/Manifold-agents/manifold/issues
Classifier: Operating System :: MacOS
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Environment :: Console
Classifier: Environment :: Web Environment
Classifier: Topic :: Software Development :: Libraries
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: End Users/Desktop
Requires-Python: >=3.11
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: jsonschema>=4.18
Requires-Dist: starlette>=0.37
Requires-Dist: uvicorn>=0.29
Requires-Dist: keyring>=24
Requires-Dist: iroh>=1.1
Requires-Dist: certifi>=2024.2
Provides-Extra: dev
Requires-Dist: pytest>=8; extra == "dev"
Requires-Dist: httpx2; extra == "dev"
Requires-Dist: httpx; extra == "dev"
Dynamic: license-file

# Manifold

Manifold runs live nodes on your Mac and shows them to people and agents at once. Each node publishes one value.
People see it as a card on a canvas. Agents read it as text and press its actions from the command line. A manifold
is a set of nodes arranged for a purpose: a trading desk, a research queue, a household.

It runs on your machine with your accounts. Other machines join by invitation and see what you grant them. No one's
code runs on anyone else's machine.

This release is for **macOS**. Apple silicon gets the Rust door; Intel Macs run the Python door. Python 3.11 or newer.

## Install

```bash
uv tool install manifold-ai
```

This installs the `manifold` command on its own, fetching Python 3.13 if your Mac has nothing new enough. `uv` is
`brew install uv`. With Python 3.11 or newer already installed, `pip install manifold-ai` or `pipx install
manifold-ai` do the same. A Mac's built-in `python3` is 3.9, which is too old.

## First manifold

```bash
manifold                         # the canvas, in your browser; the first time, it installs the core to run at login
manifold new desk --purpose "where the market stands" --section Market
```

`manifold` on its own always lands on the canvas, starting the core if it is not running. Seeing anything else means
something failed, and the line says what. `manifold -h` is the help.

Place nodes from the library, a thousand node types in a hundred domains. `manifold library` lists the domains,
`manifold library stocks` one domain's types, `manifold library weather` whatever matches a word; the canvas shows
them as a gallery.

```bash
manifold -m desk place stocks/quote Market symbol=^GSPC name="S&P 500"
manifold -m desk approve quote   # a type that reaches outside through a tool runs once you approve it
manifold -m desk ls              # what an agent reads: every card's headline values
manifold -m desk cat quote       # one card in full
```

A node that needs a key asks for it by name. `manifold key add` stores it in the macOS keychain, and it goes only
to the tool you approved it for.

## Agents

Any agent with a shell works a manifold through the same commands a person uses. One run of Claude Code or Codex
with Manifold as its tool:

```bash
manifold -m desk agent "say where the S&P stands and whether volatility is high" --can act
```

Agents that live in a manifold, with a standing task and a schedule: `manifold -m desk agents new …`. An agent runs
only on its own machine, on your own sign-in. No machine starts an agent on another.

An agent's learning outlives its run through the `memory` node (`manifold place agents/memory Knowledge`): one fact
per line, with where it came from and the day, written with `do remember`, revised or forgotten by id, read by the
next agent on any machine the section is shared with. It is a node like any other, so grants and feeds apply to it.

A fast, typed judgment — a probability, a pick, a grade — comes from a System One model through the `systemone` tool
and the `judge` node (`manifold place agents/judge Knowledge`). Set the tool up once on a machine: `manifold key add
TYPESAFE_API_KEY` for TypeSafe's jev, or `manifold tool set systemone provider=local url=…` for a model on this machine,
or `provider=custom` for any host that speaks the System One shape. Then any agent asks `do judge ask state=… question=…`,
and every judgment is logged on the card with what it cost.

## Other machines

A manifold runs on one machine. Any other machine, yours or a friend's, joins with a one-time invitation:

```bash
manifold -m desk share --role build       # on the machine the manifold lives on: prints an invitation
manifold join mf2.…                       # on the other machine
```

Roles: `read` (ls, cat), `act` (also press actions), `build` (also place, set, move and remove nodes). Approving,
inviting and keys never leave the machine the manifold runs on. A **private** section is invisible to everyone
you share with until you open it to one of them by name:

```bash
manifold -m desk private Account
manifold -m desk members allow "MacBook Air" Account
```

Your devices keep a copy of what they may see, so they can read the manifold while the machine it runs on is off.

## Where things are

| | |
|---|---|
| your manifolds, keys' names, feeds | `~/.manifold` (or `MANIFOLD_HOME`) |
| a manifold | a folder: `layout.json`, `nodes/<type>/` (`node.json`, `node.py`, `view.html`), `docs/` |
| the node library | shipped in the package; `MANIFOLD_LIBRARY` points elsewhere |
| the door | the process that carries connections between machines (Rust; `door/` in the source) |
| the canvas | `http://127.0.0.1:8730` |

The package contains code, the node library with synthetic sample data, and the door binary; nothing from the
machine it was built on. Everything you make lives in your home folder. A key goes to the macOS keychain, never to
a file. Nothing leaves your machine except what you grant to a machine you invited, through the door.

## Building a node

A node is three files. `node.json` says what it answers, its settings and the shape of its value. `node.py` has
`gather(m, s)`, which returns the value, and `act_<name>(m, s, …)` for each action. `view.html` draws the card.
`manifold bench <folder> --save --shot` runs one without a core. `library/GUIDE.md` is how library nodes are built.

## Development

```bash
git clone … && cd manifold && uv venv --python 3.13 && uv pip install -e ".[dev]"
(cd door && cargo build --release)          # the door; without it the Python door runs
.venv/bin/python -m pytest -q
```

`DECISIONS.md` holds every design decision with its reason and what would prove it wrong. `AUDIT.md` records what a
hostile machine was tried against and what remains unproven. Apache-2.0.
