What you can build with it — use cases

- Create a Lens from a conversation: ask your assistant to turn a prompt you just iterated on into a versioned Lens (create_lens), instead of losing it in chat history. - Run a Lens by name: "Run the code-reviewer lens with Topic=TypeScript" — the assistant calls run_lens, which resolves [[Parameter]] tokens from the database and hands back a finished prompt for the assistant to execute. - Build and automate a Workflow: create, run, and summarize_workflow for cost and duration — chain Lenses and tools into an automation pipeline from inside your existing coding session, no dashboard tab needed. - Spin up an Agent (AI Lenser): configure a Workflow plus a set of Lenses into an Agent, assign it tools, and manage its runs — the Agent tool group covers 12 of the 55 tools. - Discuss changes in a Thread: attach iteration notes and feedback to a Lens instead of losing the reasoning behind a prompt change in a chat log.

Every tool call runs under your authenticated identity with Supabase RLS applied — nothing runs with elevated access on your behalf. Destructive operations (delete_lens, archive_ai_lenser, closing/archiving a battle) require an explicit confirm: true.

Full reference — all 55 tools, parameter tables, OAuth details, local stdio mode for developing inside this repo, and troubleshooting: MCP Server Reference · Provider Quickstart · apps/mcp-server/README.md

Use cases

- Maintain a reusable Lens library instead of re-writing the same prompt from memory every time — versioned, parameterized, searchable. - Automate a repeated AI task into a Workflow — chain Lenses, tools, and conditional steps into a single pipeline, the same way you'd wire up automation in n8n or Zapier, but built around AI instructions and model calls instead of app-to-app triggers. - Prototype a tool-using Agent by pairing a Workflow with a set of Lenses you already trust, then hand it a schedule or an MCP connection. - Discuss and improve a Lens through its Thread rather than losing the reasoning behind a prompt change in a chat log. - Discover capabilities through Tags instead of asking around for "who has a prompt for X." - Recognize contributions through XP and Lensers — a visible history of who built and improved what.

CLI quick start

Prefer the terminal? lf gives you every Lens, Workflow, Agent, and Lenser operation without opening a browser — install it once, sign in, and go:

npm install -g @lenserfight/cli
lf --version

No install needed — try it first:

npx @lenserfight/cli --help

Then onboard:

lf init            # create .lenserfight.json (cloud mode by default)
lf auth login       # browser-based login
lf onboard          # guided first-run: auth check → profile → first template

No account, no cloud — test-drive the CLI fully offline against a local Ollama model:

lf run exec --ollama --model llama3.2 --prompt "Summarize the MIT license in one sentence"

Running lf with no arguments opens the built-in terminal dashboard — sidebar navigation across Agents, Workflows, Schedules, Memory, and more, with the same routing and safety gates as every scripted command.

Full command reference, config, and environment variables: apps/cli/README.md · CLI docs · CLI: Getting Started tutorial

Recommended: install Docker if you plan to use local mode. Cloud mode (the CLI default) and file-workspace commands (lf battle file, lf validate, lf workflow run) need no Docker at all. Docker is only required for lf use local / lf --local and lf dev, which spin up a local Supabase stack:

- macOS / Windows: Docker Desktop, then docker --version to confirm. - Linux: Docker Engine, then sudo usermod -aG docker $USER (log out/in to apply).

Quick start (web app)

Recommended: install Docker first. The local Supabase stack (Postgres, Auth, Storage, Realtime) runs in Docker containers — nothing else in this quick start needs it, but you'll hit a wall at pnpm supabase start without it.

- macOS / Windows: install Docker Desktop, then confirm it's running: docker --version. - Linux: install Docker Engine for your distribution, then add your user to the docker group so you don't need sudo for every command: sudo usermod -aG docker $USER (log out/in to apply).

Run the full product — web app, auth, and a local Supabase stack — in one command:

git clone https://github.com/conectlens/lenserfight.git
cd lenserfight
./scripts/dev-start.sh    # boots local Supabase + Vite

Then open http://localhost:3000. Full local setup guide → · Troubleshooting →

Or run each piece yourself:

pnpm install --frozen-lockfile
pnpm supabase start
pnpm supabase:db:reset

pnpm nx run web:serve     # web app  → http://localhost:3000
pnpm nx run auth:serve    # auth app → http://localhost:3004

Requires Node 22 (see .nvmrc) and Docker (for local Supabase). Pull requests target the development branch — see CONTRIBUTING.md.

Other entry points, each with its own README: the lf CLI (above), the MCP server for driving LenserFight from Claude, Cursor, Codex, or another MCP-capable assistant (below), and the Trust Gateway for local execution attestation (see gateway docs before enabling it).

Demo

<p align="center">_{Auto-generated by <a href="scripts/generate-hero-preview.mjs"><code>pnpm hero:preview</code></a> against a local instance — not staged screenshots.}</p>

Step-by-step: Cursor, VS Code, or Codex (local MCP config)

Add an entry to your MCP config (~/.cursor/mcp.json, or .mcp.json in your workspace):

{
  "mcpServers": {
    "lenserfight": {
      "url": "https://mcp.lenserfight.com/mcp"
    }
  }
}

Restart the client. On first use of a LenserFight tool it opens a browser window for the OAuth authorization flow — no client secret required.