Manifold

Coordinate teams of AI specialists on long-running, multi-step automation workflows.

Stars
★ 501
Last updated
25d ago
License
MIT
Primary language
Go

At a glance

How it runs
Self-hosted serviceWeb appFramework
Works with
Universal · cross-platformOpenAI API · Claude API
Cost
Free, no paid service needed
Setup effort
Medium · a few setup steps
You'll need
Docker with Docker Compose supportAn LLM API key or a reachable OpenAI-compatible endpointA writable host directory for WORKDIRShell / CLINetwork accessLocal filesystemMCP Server
Typical use
Automation teams coordinating several specialists on objectives that may take hours and many steps.
Not a fit if
  • Teams requiring strong production stability guarantees
  • Users unwilling to self-host and configure a model endpoint

What does this agent do, and when should you use it?

Manifold is an experimental platform for pursuing complex objectives with teams of configurable AI specialists over extended periods. Its interfaces include agent chat, a visual workflow editor, a specialist registry, isolated project workspaces, Pulse scheduling, and a playground for prompts, datasets, and experiments. It can call OpenAI, Google, and Anthropic models, as well as OpenAI-compatible endpoints backed by llama.cpp or vLLM. Built-in and MCP tools participate in workflows, while a saved workflow can itself become a specialist tool or a node inside another workflow. The recommended deployment is a self-hosted Docker Compose service accessed through a browser; a locally built binary can instead use SQLite, FTS5, Vec1, and process-local telemetry. The project is explicitly experimental and is not presented as production-ready for environments demanding strong stability guarantees.

Users define AI specialists in the Specialist registry and configure Projects as isolated workspaces. Agents load project skills from each workspace's skills/ directory and can discover universal read-only skills in $HOME/.manifold/skills and $HOME/.agents/skills through dedicated skill tools. Agent chat accepts objectives, supports collaboration across multiple turns, and can return text or configured visualizations. The Workflow editor exposes MCP tools as nodes, saves composed workflows, and makes those workflows callable by specialists or nestable inside other workflows. Pulse runs specialist tasks at intervals, daily, or once at a specified date and time, then sends results to Matrix or channels added through Skills and MCP. Manifold calls OpenAI, Google, Anthropic, or OpenAI-compatible model endpoints and also performs image generation through OpenAI, Google, or a custom ComfyUI MCP client. Its playground versions prompts, assigns them to agents, configures datasets, and runs experiments, while local telemetry can serve bounded metrics, logs, and traces.

  1. Automation teams coordinating several specialists on objectives that may take hours and many steps.
  2. Workflow designers who want to compose MCP tools visually and reuse a subworkflow as another tool.
  3. Operations or research teams scheduling specialist jobs and delivering their results to Matrix.
  4. AI application developers comparing prompt versions and datasets through repeatable agent experiments.
  5. Teams choosing between hosted model providers and self-hosted llama.cpp or vLLM endpoints.
  6. Organizations separating multiple client or research workspaces by project root and project-specific skills.

How do you install or deploy this agent?

A basic local deployment requires Docker with Docker Compose support, an LLM API key or reachable OpenAI-compatible endpoint, and a writable absolute host path for WORKDIR. Copy the examples, set at least OPENAI_API_KEY and WORKDIR in .env, and start the service:

cp example.env .env
cp config.yaml.example config.yaml

# Edit .env and set at minimum:
#   OPENAI_API_KEY=...
#   WORKDIR=/absolute/path/to/your/manifold-workdir

docker compose up -d manifold

Open http://localhost:32180 after startup. Node 22, pnpm, and Go 1.26.3 are only required when developing outside Docker or building the binary locally; a host build also needs Chrome or another Chromium-compatible browser for browser-driven tools.

How do you use this agent?

After starting the service, open the web interface at:

http://localhost:32180

Define specialists in the Specialist registry, configure isolated workspaces under Projects, and assign objectives through Agent chat. For structured automation, compose the automatically exposed MCP nodes in the Workflow editor and save the result; specialists can invoke that workflow, or it can be inserted into another workflow. For recurring work, use Pulse to select an interval, daily schedule, or one-time date and time, then configure Matrix or another channel exposed through Skills or MCP. When running a locally built binary with SQLite configuration, inspect storage before startup with:

./dist/manifold storage doctor --json

The standard host build is:

make build-manifold

To expose beta UI links, use either supported build command:

make build-manifold-beta
make build-manifold FEATURE_GATE=beta

What are this agent's strengths and limitations?

Pros
  • Supports OpenAI, Google, Anthropic, and OpenAI-compatible endpoints, including open-weight models served through llama.cpp or vLLM.
  • Automatically turns MCP tools into visual workflow nodes and allows saved workflows to be called or nested as tools.
  • Combines specialist configuration, isolated projects, collaborative chat, scheduling, image generation, and prompt experiments in one self-hosted interface.
  • Can operate with SQLite, FTS5, Vec1, and bounded process-local telemetry instead of requiring external database and telemetry services.
Limitations
  • The project is explicitly experimental and does not promise the stability needed for production-critical environments.
  • Initial deployment requires Docker Compose, configuration files, a writable WORKDIR, and either model credentials or a compatible endpoint.
  • Building outside Docker adds Node 22, pnpm, and Go 1.26.3 toolchain requirements.
  • Observability is still described as a work in progress, while stricter workflow enforcement, tool-error recovery, and safe compaction modes require runtime configuration.

How does this agent compare with similar options?

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
Manifold This agent 60 · Some gaps Self-hosted serviceFree ★ 501 25d ago Go OpenAI API · Claude API
Keinsaas Navigator 69 · Some gaps Self-hosted serviceFree + model costs ★ 1.2k 1mo ago TypeScript OpenAI API · Claude API
Agentspan 62 · Some gaps CLIFree + model costs ★ 495 10d ago TypeScript OpenAI API · Claude API
AGNT Agent OS 52 · Major gaps Desktop appFree + model costs ★ 546 3d ago JavaScript Codex · Claude Code · OpenAI API · Claude API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Some gaps
60/ 100 5-point scale 3.0 / 5
Trust 12/29
Reliability 9/14
Adaptability 12/18
Convention 14/18
Effectiveness 7/13
Verifiability 6/8
Why each dimension lost points
Trust12 / 29 · 2.1/5

Project-root isolation, read-only universal skills, individually enabled MCP tools, and read-only GitHub workflow permissions provide a reasonable least-privilege foundation, but no complete runtime sandbox or per-action authorization model is shown. The source does not establish mandatory user confirmation before high-impact tool calls, scheduled execution, or outbound delivery. The README identifies remote model providers, optional telemetry, Matrix, and extensible external channels, but does not provide a complete field-level data map, retention policy, or recipient inventory. API keys are configured through an environment file, while rotation, log redaction, and data-at-rest protections are not documented. Most dependencies are versioned and release checksums are produced, but Actions use mutable major tags, CI downloads and executes a remote installer, goimports is installed at latest, and the release workflow creates an empty THIRD_PARTY_NOTICES.txt; no vulnerability scan or SBOM is shown. External-effect capabilities are explicit, but confirmation, scoping, and revocation controls are not. SQLite provides durable state, yet backup, migration rollback, and task compensation are undocumented. MIT attribution and the dependency manifest are clear, but third-party notices are incomplete and publisher identity remains unknown.

Reliability9 / 14 · 3.2/5

The README, build workflows, and tests are broadly consistent about the Go version, Forge build, release contents, and selected API behavior; full marks are withheld because only part of the system is represented and the stable feature-gate wording is ambiguous. Dependencies are enumerated and mostly pinned, with Docker, host builds, and multi-platform packaging described; dedicated self-hosted runners, remote installation steps, and optional model assets reduce general availability. CI emits concrete errors for unsupported targets, runner mismatches, formatting, and missing tools, while the TTS tests establish 400 and 422 responses; comprehensive user-facing failure and recovery behavior for long workflows, providers, MCP, and scheduled tasks is not shown.

Adaptability12 / 18 · 3.3/5

The intended audience and long-horizon, multi-agent use case are clear, with chat, image, scheduling, workflow, project, and experiment scenarios, although role-specific operational guidance is absent. The experimental warning, work-in-progress observability, stable/beta gates, and configurable strict harness modes describe meaningful boundaries, but there is no complete tool-permission or unsupported-scenario matrix. Interval, daily, one-time, and tool-invoked workflows are identified, yet collision handling, repeat execution, time zones, idempotency, and natural-language trigger disambiguation are not documented. Environment fit earns full marks because the evidence covers Docker and host operation, SQLite and Postgres, remote and local model endpoints, several model providers, and six OS/architecture release targets.

Convention14 / 18 · 3.9/5

The README has clear feature, deployment, development, and specialist-document navigation, supporting full information-architecture credit. The fast path specifies prerequisites, copied configuration, required variables, startup, access URL, and a host alternative, so installation guidance is thorough. Product and subsystem terminology is broadly consistent, but experimental status and evolving strict/beta modes limit evidence of long-term naming stability. Screenshots, commands, and configuration examples are useful, though no consolidated FAQ or broad troubleshooting examples are present. Known limitations earn full marks because experimental status, production cautions, WIP functionality, optional dependencies, and configuration-gated strict modes are explicitly disclosed. The complete MIT text supports full license credit. The release workflow accepts version labels and builds platform artifacts, but no semantic-version policy, release history, or changelog is supplied. A copyright holder and repository organization are named, but maintainers, support channels, response commitments, and verified publisher identity are not established.

Effectiveness7 / 13 · 2.7/5

Chat, visualization, image, scheduling, workflow-editor, project, and experiment surfaces indicate that outputs can be viewed, scheduled, composed, and reused, but no end-to-end artifact contract or acceptance criteria are provided. Combining agent teams, MCP nodes, nested workflows, dataset experiments, and multiple model backends offers clear potential value beyond one-shot prompting, although the benefit is primarily asserted rather than comparatively measured. Deployment requirements and one optional model-size estimate are disclosed, but token spending, provider charges, resource baselines, latency, and controls for the cost of long-running workflows are not addressed.

Verifiability6 / 8 · 3.8/5

Important deployment and build claims trace to go.mod, CI, the release workflow, and interface tests, while screenshots and documentation links aid navigation; many product-level capabilities remain supported only by README statements in the supplied material. The Go version, package composition, target platforms, Forge scenario testing, and TTS error behavior are corroborated across files, but scheduling, permissions, telemetry, and long-horizon collaboration lack comparable cross-source support. The source consistently labels experimental and work-in-progress areas, distinguishes stable from beta behavior and local from external dependencies, and does not present static evidence as an executed result, justifying full credit for fact/inference separation.

Risks and how to mitigate them
  • Not found in source: confirmation before actingTurn on (or add) a confirmation step before it acts, and try it in a sandbox or test environment before real data.
  • The platform can let agents invoke tools, run scheduled tasks, and send results to external services, but the supplied source does not establish mandatory per-action confirmation, revocation, or compensation for these high-impact effects.
  • Remote model providers, MCP, Matrix, and optional OTLP broaden data flows; verify transmitted fields, log redaction, retention, and recipients before processing sensitive information.
  • CI uses mutable Action major tags, a remote installer script, and a latest tool version; the release workflow creates THIRD_PARTY_NOTICES.txt as an empty file, leaving supply-chain and attribution controls incomplete.
  • The project explicitly describes itself as experimental; production stability, execution correctness, and recovery of long-running workflows must not be inferred from this static review.
Evidence confidence: Low Reviewed Oct 05, 2026 Reviewed revision 7bee437df13a
See the full review method →

FAQ

Must I pay for a commercial model API?
No. You can provide OpenAI, Google, or Anthropic credentials, or connect an OpenAI-compatible endpoint served through llama.cpp or vLLM. Manifold still requires some reachable LLM provider.
Does a deployment require an external database or telemetry stack?
Not for the locally built host configuration. SQLite is the default durable backend, Postgres is optional, and bounded metrics, logs, and traces can be served from process-local telemetry.
Are project files separated?
Each project is isolated to its own root path. Project skills come from its skills/ directory, while universal skills in the two documented user directories are discovered as read-only resources.
Where can scheduled task results be sent?
Matrix is supported natively. Skills or MCP integrations can extend the set of channels available to Manifold.
Is it suitable for a production-critical deployment?
Not without additional validation and safeguards. The repository identifies Manifold as an experimental frontier AI platform and warns against production use where strong stability guarantees are required.
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents