Folio

A team wiki that lives in Git, edited live in the browser, with AI agents reading and writing the same pages over MCP.

Stars
★ 74
Last updated
today
License
MIT
Primary language
TypeScript

At a glance

How it runs
Self-hosted serviceWeb appMCP server
Works with
Portable with changesChatGPT · Codex · Claude Code · Claude.ai
Cost
Free software; you pay for model usage
Setup effort
Medium · a few setup steps
You'll need
DockerGitPostgreSQLRedisNode.js 22.12 or newer (development)Shell / CLINetwork accessLocal filesystemMCP Server
Typical use
A product team's docs/ folder: bind the repository folder as a space, let a technical writer edit in the browser while developers see ordinary commits with an author name via git pull.
Not a fit if
  • Teams that require pull-request review before changes land (Folio pushes straight to the space's branch)
  • Teams that want a hosted SaaS and will not run Docker, PostgreSQL and Redis
  • Users who need Vercel, Netlify or other serverless hosting
Source review
61/100 · Some gaps

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

Folio is an open-source, self-hosted alternative to Notion and Confluence built around one rule: the Git repository is the wiki. Documents, data tables, whiteboards, forms, Obsidian canvases/bases, artifact pages and uploaded files are all plain files in a space's repository; the database holds only the index, access rights and live-editing state. The browser offers Reading, Live edit and Source modes with real-time co-editing for multiple people, and pages stay editable offline until the connection returns. AI comes in two layers: the built-in Folio AI assistant (Ask for read-only, Agent for writes) and an MCP server exposing 41 tools that Claude Code, Cursor, claude.ai, ChatGPT and other clients reach via a personal access token or OAuth 2.1, never exceeding the token owner's rights. Deployment is docker compose up -d; the assistant runs on a Cursor key you supply or an administrator provides, and everything else works without one.

Folio scans Markdown files in a Git repository and renders them as pages, storing whiteboards as editable Excalidraw SVGs, data tables as a single .table.md file, forms as .form.md, and Claude artifacts as a <name>.artifact/ folder. Edits sync in real time in the browser and are committed after roughly 90 seconds of quiet or immediately on Sync, with the last editor as commit author and the message folio:update. The built-in assistant and outside agents use the same tool set: the /mcp endpoint offers 41 tools covering listing and searching spaces, reading and writing pages, building forms, editing table columns and views, reading outlines, tags, properties and links, querying the link graph (get_graph), publishing artifacts (publish_artifact), and reading history. A .agent folder in each space defines that space's assistant instructions as ordinary pages, and /admin/assistant shows answer ratings, surveys and a list of unanswered questions. Publishing turns a space into a read-only site on a path, subdomain or custom domain, optionally with search, downloads and a visitor-facing Ask AI.

  1. A product team's docs/ folder: bind the repository folder as a space, let a technical writer edit in the browser while developers see ordinary commits with an author name via git pull.
  2. A company that needs a self-hosted knowledge base: run one Docker stack on a VPS, assign administrator/editor/viewer roles per space through the access matrix, and keep an audit log of every grant.
  3. Teams automating with Claude Code or Cursor: have the agent read the release process, write release notes and add a roadmap row through MCP, saved in Git under that person's name.
  4. Teams publishing public docs: flip a space to a public website with in-space search, Markdown/PDF/DOCX downloads and an optional Ask AI for visitors.
  5. Field or travel work: keep writing on already-opened pages and whiteboards offline, then let changes sync back to the same address without duplicates.
  6. Migrating off Confluence: point Folio at a Confluence Cloud or on-premises page or tree and import it as Markdown, with Cloud whiteboards becoming Excalidraw boards.

How do you install or deploy this agent?

You need Docker and Git; nothing else:

git clone https://github.com/evergreen-it-dev/folio.git
cd folio
docker compose up -d

The first start builds the application and takes a few minutes. Then open http://localhost:4870 and create the first account, which becomes the instance administrator. For a VPS there is a one-command script in deploy/vps, or the same compose file with --profile https for automatic HTTPS; ready-made kits for Coolify, Railway, Render, DigitalOcean, Dokploy, CapRover, Easypanel, Portainer and Fly.io live in deploy/.

For development:

cp .env.dev.example .env
docker compose -f docker-compose.dev.yml up -d
npm install
npm run dev

The dev server listens on http://localhost:4871 and needs Node.js 22.12 or newer (22.13 or newer for the assistant). Vercel, Netlify and other serverless hosts are explicitly not supported.

How do you use this agent?

After creating your account, the welcome wizard asks what to create first — a document, a whiteboard or a data table — or you can connect an existing Git repository from the same screen. The shortest way to attach an agent over MCP:

claude mcp add folio --transport http https://wiki.example.com/mcp \
  --header "Authorization: Bearer folio_pat_…"

A personal access token carries a read or write scope and never more rights than its owner. For claude.ai or ChatGPT, add https://wiki.example.com/mcp as a custom connector, sign in to Folio and allow read or read + write on the consent screen. Any page, optionally with its child pages, is available as clean Markdown:

curl https://wiki.example.com/share/<token>.md

Folio AI runs on Cursor keys, chosen in this order: the person's own key, the space's key, the instance key, then CURSOR_API_KEY from the server environment. A space administrator sets the space key from the space menu; an instance administrator can disable personal keys so everyone uses the shared one. Without any key, everything except the assistant still works.

What are this agent's strengths and limitations?

Pros
  • Content ownership is structural, not a promise: pages, whiteboards, tables and forms are readable files in your own Git repository, so stopping Folio tomorrow leaves the content intact.
  • A genuinely complete agent interface: 41 MCP tools over /mcp, the same implementation the built-in assistant uses, with Ask mode disabling write tools server-side rather than merely hiding them.
  • Docs-as-code is handled with real care: you can bind only a docs/ subfolder without writing ids into files, page moves rewrite inbound and outbound links in one commit, and conflicts are listed per space with a reset-to-Git path that backs up first.
  • Layered permissions: space roles, page-level access, share links and token scopes, with instance admins excluded from private spaces by default and every grant or revoke written to an audit log.
  • Self-hosting is cheap and quiet: one Docker stack, no telemetry by default, and optional PostHog/Sentry hooks that stay off without your own keys or DSN.
Limitations
  • LLM access is locked to a single vendor's key system — Cursor only, with others marked not supported yet — and the assistant is unusable without a key.
  • No pull-request workflow: a space follows exactly one branch and pushes straight to it, so a protected branch makes the push fail and teams must route through a docs branch.
  • Heavier runtime than a static docs site: PostgreSQL, Redis and a persistent volume are required, and serverless hosting is explicitly unsupported.
  • Documented ceilings constrain scale and edge cases: no .mdx pages, 20,000 rows per table, a 10,000-page graph limit, no graph on public sites, and artifacts that cannot call Claude or your own APIs.
  • Young product: 0.1.0 landed on 29 Sep 2026 and 0.2.0 on 14 Oct 2026, and the public demo wipes its data every 24 hours.

How does this agent compare with similar options?

The README frames Folio explicitly against Confluence and Notion, which keep content in a database and offer Git as an export — Folio inverts that, making the repository the primary store. The project site also publishes comparison pages for Confluence, Notion and self-hosted wikis. Against GitBook-style docs tools it stresses browser editing with no IDE required plus real-time collaboration; against Obsidian it opens .canvas and .base files while adding team permissions and publishing.

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

Agent Source review Form / cost Stars Updated Language Full support on
Folio This agent 61 · Some gaps Self-hosted serviceFree + model costs ★ 74 today TypeScript ChatGPT · Codex · Claude Code · Claude.ai
NextClaw 58 · Major gaps Desktop appFree + model costs ★ 262 today TypeScript Codex · Claude Code
Paca 53 · Major gaps Self-hosted serviceFree ★ 2k today Go Codex · Claude Code
PocketPaw 46 · Major gaps Desktop appFree + model costs ★ 893 1mo ago Python Codex · OpenAI API · Claude API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Some gaps
61/ 100 5-point scale 3.1 / 5
Trust 14/29
Reliability 9/14
Adaptability 14/18
Convention 13/18
Effectiveness 7/13
Verifiability 4/8
Why each dimension lost points
Trust14 / 29 · 2.4/5

SECURITY.md advises read-scope tokens for agents and forbids treating page text as instructions; INSTALL notes GitHub OAuth requests full repo scope but offers fine-grained tokens, showing least-privilege awareness (2). No described user-confirmation step for agent writes beyond permission bounds, deducted to 1. Data-flow transparency is good: AI depends on a Cursor subscription and sends pages there; PostHog/Sentry are off by default with listed fields (2). Sensitive data: FOLIO_SECRET encrypts tokens, Sentry masking, demo warnings (2). Dependency security shows only overrides pinning nanoid/katex, no audit or lockfile evidence, CI uses --no-audit, deducted to 1. External effects: agents can write Git, publish artifacts and public sites; sandbox and CDN allowlist exist but no confirmation for irreversible external actions, 1. Rollback: Git history, backup branch, file version restore (2). Source attribution: commit authorship and MIT notice, but publisher unverified and agent-generated content attribution unclear, 1.

Reliability9 / 14 · 3.2/5

Docs are internally consistent: README, INSTALL, LIMITATIONS agree on Git-first, 90s commit, offline scope (2). Dependency availability: Node>=22, Postgres/Redis stated, multi-arch image published, but no lockfile evidence, 2. Failure messages: troubleshooting section, sync states and conflict listing, Not saved indicator (2).

Adaptability14 / 18 · 3.9/5

Audience and scenarios cover team wiki, docs-as-code, public sites, agent integration thoroughly (3). Capability boundaries are extremely detailed in LIMITATIONS (3). Trigger precision: agent invocation conditions and MCP tool boundaries are scattered, no explicit trigger rules, 1. Environment fit: Docker and many PaaS supported, serverless explicitly unsupported, requires Postgres/Redis, 2.

Convention13 / 18 · 3.6/5

Information architecture is clear and well-sectioned (3). Install notes are very complete (3). Naming stability: version 0.4.0 but no CHANGELOG, no stability commitment, 1. Examples and FAQ: videos, screenshots, scenarios but no formal FAQ, 2. Known limitations are exhaustive (3). License MIT complete (3). Versioning/changelog missing (1). Maintenance responsibility: publisher unverified, SECURITY only fixes latest version, 1.

Effectiveness7 / 13 · 2.7/5

Output usability: pages/tables/boards/artifacts are readable and exportable (2). Marginal value: Git-native plus first-class agents is genuinely differentiated (2). Cost-benefit: needs Cursor subscription, 2GB RAM, Postgres/Redis, single AI vendor dependency, 1.

Verifiability4 / 8 · 2.5/5

Claim traceability: many README claims are self-asserted with few pointers to code/tests (1). Cross-source corroboration: docs corroborate each other but no independent third-party evidence (1). Fact/inference separation: LIMITATIONS clearly separates implemented vs not, good (2).

Risks and how to mitigate them
  • The AI assistant depends on a Cursor subscription and sends page content to that service; assess data egress and vendor lock-in.
  • GitHub OAuth requests full repo scope; prefer fine-grained tokens.
  • Publisher identity is unverified; maintenance responsibility and update path are unclear, so audit before production use.
  • No lockfile or dependency-audit evidence and CI uses --no-audit; assess supply-chain risk yourself.
  • Agent writes and public-site publishing lack an explicit user-confirmation flow; restrict permissions at deployment.
Evidence confidence: Low Reviewed Oct 21, 2026 Reviewed revision 9515ad6ce2b2
See the full review method →

FAQ

Is it usable without any AI provider key?
Yes. The README states that without a key, everything else in Folio works as usual — documents, whiteboards, tables, forms, access control, public sites and the MCP tools. The side-panel Folio AI assistant specifically needs a Cursor key, resolved from the user, the space, the instance, then CURSOR_API_KEY.
Can an agent change pages the token owner cannot see?
No. A token or OAuth grant never has more rights than its owner, a read token cannot write, and administrative actions are unavailable to tokens at all. Folio AI's Ask mode disables write tools on the server, and graph queries apply access checks so pages a reader cannot open are not nodes, ghosts or edges.
Can I attach it to the docs/ folder of an existing product repo?
Yes, with the caveat that the mode matters. A space bound to a docs/ root records page ids in its own index and adds only one hidden file, docs/.<slug>.folio. A space over the whole repository writes an id into every page plus a small root file unless an administrator enables "Light footprint". Either way the space follows one branch and pushes directly, without pull requests.
What happens to private pages when I publish a space?
Pages with their own access restrictions, the .agent folder and templates are never published. But restrictions are not inherited by child pages, so you must lock every page that should stay closed before publishing. Publishing decisions such as visibility, downloads, Ask AI and indexing live in the database, while the site's look lives in .folio/ in the repository.
What does self-hosting actually cost to run?
The software is MIT-licensed and free. You pay for the host and for AI usage, which runs on your own Cursor key or a key an administrator provides — Folio does not resell or mark up AI. There is no telemetry by default, and optional PostHog analytics or Sentry error reporting only activate with your own key or DSN.
View on GitHub ↗ Install ↓

Compare agents like this one

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

Related agents