Local-First AI-Readiness. Yours to Control, Forever.
Pipulate - Local-First AI-Readiness for the Agentic Web (formerly AI SEO Software)

AI-Readiness Software to Future-proof You

In an era dominated by cloud subscriptions and complex frameworks, Pipulate champions a local-first revolution. It’s a free, open-source framework that transforms how you build AI-assisted applications by embracing a radical philosophy: explicit code is better than abstract code when you have AI to help manage it. Think: Notebooks without having to look at the Python code.

Quick Start: Be Running in 5 Minutes

Want to skip the philosophy and just see what this does? Paste this into your terminal:

curl -fsSL https://pipulate.com/install.sh | bash

Note: Nix creates a perfectly reproducible environment, like Docker but more integrated. The first setup might take a few minutes to download dependencies, but subsequent launches are fast.

# 2. Launch it
cd ~/pipulate && nix develop

What you get: A local web app at http://localhost:5001 with step-by-step workflows, integrated AI chat, and a JupyterLab instance at http://localhost:8888. No cloud required.

Success looks like: A JupyterLab Notebook tab opens in your default browser and Onboards you to the FastHTML web app.

These few commands:

That’s it! You now have a local-first development environment with AI integration.

4. Run It Again!

  1. You can just forcibly exit out of that Terminal it’s running from.
  2. Open a new Terminal, and once again:
cd ~/pipulate
nix develop

5. The Big Reset (If Necessary)

Things sometimes go wrong. This is how you do a full Pipulate reset. This will also delete anything you downloaded with Pipulate. Adjust custom install name to what you used.

rm -rf ~/pipulate
curl -fsSL https://pipulate.com/install.sh | bash

Wait for the JupyterLab tab to auto-open, then run the Onboarding notebook to unlock the Pipulate app.

The Local-First Revolution in AI-Assisted Development

🔭 Why “AI-Readiness”? Because the Honeybot Watches.

The name changed because the visitors changed. This project grew out of SEO — that lineage is worn openly — but the agents arriving at your site today aren’t search crawlers building an index for humans to browse. They’re AI agents reading for themselves, on behalf of whoever sent them.

We don’t guess at this. A retired laptop in a closet — we call it the Honeybot — serves a real site bare on the open internet, no CDN between it and the world, and records every visitor at the wire like fish in a lit tank. What the tank shows:

That is what “AI-readiness” means here: legible, verifiable, and negotiable to machine visitors — witnessed, not asserted. (This very site practices it: request any article with Accept: text/markdown and the master appears.)

🎯 For Practitioners Readying Clients for the Agentic Web

Use apps that produce client-ready “deliverables” with AI assistance — the craft that grew out of SEO, pointed at the agents that now do the reading.

Integrated Data Science Environment

Jupyter Notebooks run alongside the FastHTML server, allowing developers to prototype workflows in a familiar environment before porting them to Pipulate’s step-based interface for end-users. The same Python virtual environment (.venv) is shared, and ad-hoc package installation is supported. If you’re using Cursor, VSCode or Windsurf, set your Ctrl+Shift+P “Python: Set Interpreter” to “Enter Interpreter Path” ./pipulate/.venv/bin/python. You might have to adjust based on the folder you use as your workspace. But then you’ll have a Python environment unified between Cursor, JupyterLab and Pipulate.

      ┌──────────────────┐    ┌──────────────────┐
      │   Jupyter Lab    │    │    FastHTML      │
      │   Notebooks      │    │     Server       │
      │ ┌──────────┐     │    │  ┌──────────┐    │
      │ │ Cell 1   │     │    │  │ Step 1   │    │
      │ │          │     │--->│  │          │    │
      │ └──────────┘     │    │  └──────────┘    │
      │ ┌──────────┐     │    │  ┌──────────┐    │
      │ │ Cell 2   │     │    │  │ Step 2   │    │
      │ │          │     │--->│  │          │    │
      │ └──────────┘     │    │  └──────────┘    │
      │  localhost:8888  │    │  localhost:5001  │
      └──────────────────┘    └──────────────────┘

🛠️ For Developers

Transform your Jupyter Notebook experiments into production-ready workflows:

What You Can Build

Pipulate excels at data processing workflows and AI-assisted applications:

How It Works: Simplicity Meets Power

Pipulate runs like a desktop app but uses web technologies. Think Electron, but better:

Why Local-First Wins

Cloud-First Pipulate Local-First
💸 Monthly subscriptions 🆓 Free forever
🔒 Vendor lock-in 🔓 Full control
📡 Internet required 🏠 Works offline
🐌 API rate limits ⚡ No limits
👁️ Data mining 🔐 Complete privacy
🔄 Constant updates break things 🛡️ Stable, reproducible environment

Why Pipulate? The Philosophy That Changes Everything

Traditional development follows the DRY (Don’t Repeat Yourself) principle, creating abstract, complex systems that are hard to understand and modify. Pipulate embraces WET (Write Everything Twice) - explicit, readable workflows that are:

Deep-dive docs live in the repository README so this site can stay small and truthful.

The Technical Magic

# This is how simple Pipulate code looks
@rt("/process-data")
def process_data():
    return Div(
        H1("Processing Complete ✅"),
        P("Your data has been analyzed locally"),
        hx_get="/next-step",
        hx_trigger="load"
    )

No template languages. No build steps. No client-side JavaScript frameworks. Just Python functions that generate HTML, powered by HTMX for seamless interactivity.

Architecture Overview Diagram

This diagram illustrates the high-level components and their interactions

                 ┌─────────────┐ Like Electron, but full Linux subsystem
                 │   Browser   │ in a folder for macOS and Windows (WSL)
                 └─────┬───────┘
                       │ HTTP/WS
                       ▼
    ┌───────────────────────────────────────┐
    │           Nix Flake Shell             │ - In-app LLM (where it belongs)
    │  ┌───────────────┐  ┌──────────────┐  │ - 100% reproducible
    │  │   FastHTML    │  │    Ollama    │  │ - 100% local
    │  │   HTMX App    │  │  Local LLM   │  │ - 100% multi-OS
    │  └───────┬───────┘  └──────────────┘  │
    │          │                            │
    │    ┌─────▼─────┐     ┌────────────┐   │
    │    │MiniDataAPI│◄───►│ SQLite DB  │   │
    │    └───────────┘     └────────────┘   │
    └───────────────────────────────────────┘

This complete, self-contained environment runs identically on any operating system, providing the foundation for all Pipulate workflows and AI interactions.

The Repository Is the Documentation

This public site is now the launchpad: install, orient, and then hand off to the source of truth. The detailed philosophy, workflow patterns, and developer notes live in the repository where the code changes with them.

  1. Repository README - Complete overview, philosophy, and usage notes
  2. GitHub Repository - Source code, issues, and project history

System Requirements

Join the Local-First Revolution

The future of software development is looking more like the past, but with AI capabilities that make it even better. It’s a future where:

Start your revolution today.

Install Pipulate → Read the README → View the Code →

Pipulate is free and open source software created by Mike Levin. Join the movement toward local-first, AI-assisted development.