QUICK START: build apps, automate any project, and get personalized tech help, for just a few pennies, in a few minutes, using an AI agent

1194 views Pinned
Nick Antonaccio
Nick AntonaccioAdmin
Jul 12, 2026 at 00:10 (edited, 236 revisions)
#1

Mastering an LLM coding agent is arguably the most impactful skill in modern technology. No other tool provides a comparable return for the time and effort invested.

Here's a short TL;DR to get started

  • Set up an API key at https://openrouter.ai
  • Install Node.js from https://nodejs.org
  • Install Pi coding agent with the command: npm install -g @mariozechner/pi-coding-agent
  • Run Pi at your command line, and enter /login (openrouter) & /model (deepseek-4-pro) settings
  • Ask Pi to create an app for you, or to complete a useful task.

Detailed step-by-step instructions are covered in the tutorial below.

Why are AI coding agents such a big deal, and what's the best way to dive in?

Learning to use an AI coding agent enables you to accomplish a broad scope of technology goals, which would otherwise require years of experience to master. AI agents don't just provide instructions to guide you through completing tasks, as chatbots do - instead, they actually do the work for you. Install the agent software, communicate a goal in plain English, and the agent completes that work directly on your computer.

Some demo examples and basic info

The example apps in this tutorial include many games and visual layout examples, because they're fun to look at, and easy to instantly appreciate, but you can use the Pi coding agent to build virtually any category of functional, practical, technically intricate, custom software, without having to know anything about code.

You can build, own, and run as many apps as you want, directly on any computer you own. Or you can publish dozens of such apps online, simultaneously, for less than $5/month, using a single VPS (Virtual Private Server) service from hosting companies such as https://contabo.com and https://ovhcloud.com

You can create apps that run on any modern desktop or mobile device such as Windows, Mac, Linux, Android, iOS, Chromebook, gaming machines, etc.

You can also use Pi as a digital assistant, to help accomplish all sorts of deeply useful tech tasks. Even if you're already technologically capable, Pi keeps you from getting mired in complex details, and helps you apply time & effort to higher level project goals.

Commercial AI agents such as Claude Code, Codex, Cursor, and Replit are other options that work effectively, but they tend to impose restrictive usage constraints, and can cost up to 200x more than 'open source' agents such as Pi.

Pi is light weight and ergonomic to run, on any computer/device you already own. It fires up fast and is simple to use. You can even install it on your phone. Pi feels like a tiny tool, but the outsized capabilities it enables are wickedly powerful.

To start building custom apps, or to get personalized help with any tech goal you want to achieve, just follow the detailed steps below to install your own Pi coding agent (alternative agents are covered below too). It only takes a few minutes . You can use any computer, and you don't need any prior skills or any special hardware.

Here are the install details, to get started quickly:

What is Openrouter?: Openrouter provides the AI model 'brains' you need to accomplish local artificial intelligence work. It is possible to run those models directly on a computer you own, but it's far easier, less expensive, and more effective to start with Openrouter (an intro to self-hosting AI models is covered later in this tutorial).

Openrouter's service is provided through an 'API' connection to a remote server, which your local computer accesses via the Internet. With Openrouter, you can choose to use any of the common commercial or open-source AI models (ChatGPT, Claude, Gemini, Grok, Deepseek, etc.), and pay only for the exact 'token' processing activity you consume. Your AI 'inference' computations are performed on powerful GPUs (Graphics Processing Units) running in a data center, and that processing power can be applied to any AI work you want to perform, without needing to own any sort of special local hardware (i.e., you don't need a GPU or an expensive computer system - with Openrouter you rent only the exact compute resources you need, typically for just pennies at a time). Openrouter provides the flexibility needed to use any AI model, so you're not tied to a single company's service offerings.

Add a few dollars to your Openrouter account, copy/paste the API key you create, and save it in Notepad (or Google Docs, or anywhere else you can find it later).

It's recommended you start with at least $10 in a new Openrouter account, because that amount unlocks your free model limit from 50 to 1000 requests per day, and enables full access to paid models.

You only ever pay for tokens used to complete tasks with Openrouter models, which you execute. Most processes will cost just a few cents to perform, especially if you use less expensive models (many of the new inexpensive models are entirely capable of completing very complex goals).

You can set up automatic funding refills with Openrouter, and/or ensure that usage is limited to a dollar amount you specify.

Select the installer for your operating system and accept the defaults.

NOTE: When you install Node.js on Windows, the installer includes a checkbox for 'Tools for Native Modules'. You do not need to install these extra tools to run Pi. If checked, this step launches a command line script after the main installation to set up several dependencies required for compiling C/C++ addons (Chocolatey, Python, Visual Studio Build Tools). Just skip this entire piece for now.

  • If you're using a Windows computer, open a new PowerShell or CMD window and copy/paste the following line. If you're on a Macintosh or Linux machine, open a Terminal window and paste this line:

npm install -g @mariozechner/pi-coding-agent

(then press the Enter key on your keyboard)

To run Powershell or Terminal:

on a Windows PC type 'Powershell' into your Windows search bar

on a Mac press Command (⌘) + Space bar and type the word 'Terminal'.

  • If you get a permission error in Mac or Linux, add the word 'sudo ' to the beginning of the line above, and run it again. If you get a permission error in Windows, right-click your Powershell icon, select 'Run as administrator', enter the following line, then run the Pi install line above again:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

If you don't get any error, continue with the next step.

  • In your Powershell, CMD, or terminal window, run Pi by typing pi into the console.

(then press the Enter key on your keyboard)

  • The first time you run Pi, you'll see a message that says Warning: no models available. Do the following:

    • type /login at the Pi prompt
    • select 'Use an API key' (use arrow keys to select, then press Enter)
    • scroll down to 'Openrouter'
    • enter your Openrouter API key (which you created & saved in the first step above).
  • Type /model to choose an AI model you want to use, to power your Pi agent's creative and productive capabilities. Select deepseek/deepseek-v4-pro to start out.

Use Pi!

Now that your installation is complete, you can run Pi again any time by typing pi into your command line (Powershell, cmd, terminal, etc.).

Try asking Pi to build an app for you - just type a natural language prompt at the Pi command line.

Here are a couple quick one-off vibe coded games and demo apps that I made with Pi, on a little $87 Windows 11 netbook, using Deepseek 4 Pro (via the Openrouter API). All these apps together cost 24 cents and took just a few minutes to build:

My prompt for the space game was:

create a 3D space shooter reminiscent of the old Netwars game
(Netwars was one of the first 3D games in the early 1990s).

Deepseek did a great job - absolutely worth the single $.01 (1 penny) it cost to build ;)

You can choose to build anything, not just games. My prompt to build the business app was:

Please create a scheduling app in flask for a software development firm, which tracks employee payroll hours and payables, and also generates invoices per client project for all tracked billable hours. The admin interface should have a way to set up employee information including their payable rate, as well as client info and client projects, including their billable rate, and a scheduling system which enables employees to schedule meetings with other employees and/or with clients (and to track those hours too). Please plan this application and build it in baby steps. Please work autonomously once you get started, without asking me questions after the plan is constructed.

That application cost $.045 (4 and a half pennies) to build with Pi and deepseek-4-pro, and it completed first-shot, in a single automated run, without any errors. I just entered the prompt into Pi and let it work until the app was complete.

(BTW, 'flask', mentioned in the prompt above, is a web development platform used in the Python programming language ecosystem - you don't need to know about that ... yet).

You don't need any more instructions - Pi will guide you

Interacting with Pi at this point will feel a lot like interacting with ChatGPT, or any of the chatbots for Claude, Gemini, Grok, Deepseek, etc.

The big difference is that Pi gives those 'Large Language Models' (LLMs) the ability to actually work with files and resources directly on your computer.

That difference significantly changes the dynamics of how AI driven code generation works. It dramatically cuts down on the time, human labor, and complexity involved in developing apps. In fact, it means that you don't even have to understand how software development languages and tools work, at least to start out (this was previously a lifetime endeavor for human beings!).

Instead of describing the setup of your development PC to your chatbot, prompting it to generate some particular piece of code, using a particular programming language & libraries, manually saving that code into a file in your project, then going back and forth with the LLM in a conversation that involves pasting results of code execution tests, debug errors, and other essential feedback - repeating that process of editing, running and testing pieces of code until all features are built and all the bugs are worked out - instead, your chosen LLM can work autonomously, iterating through all those numerous steps as needed, entirely on its own, until your specified task is completed, without any help from you. It writes your code, runs your app, reads debug output, applies fixes, and repeats. You can even set up Pi to work for days in a row to achieve very difficult goals.

This setup eliminates a huge amount of the traditional work required to build software applications, and it progresses much more quickly than it ever could with a human performing manual interactions.

You can try building any sort of app you imagine. Start with something small and simple, then learn to break down bigger feature-filled software into smaller development pieces.

When you build an app that will have many parts, tell Pi to make a plan, and tell it to follow that plan step by step autonomously until the app is completed, without stopping to ask you questions. Of course you can continue to adjust an app after each version is built, specifying more details about UI, logic, and workflow, iterating endlessly until an app is finally crafted exactly as you intend, but you can step back and let Pi work quickly on its own.

You can 'steer' Pi while it's in the middle of working on a task. Just enter a new prompt, and Pi will work that new prompt into the already running inference task (ChatGPT recently added a similar feature, so this capability may already be familiar).

The key to getting good results with any AI coding agent, is to submit very detailed and specific prompts. In general, the more detail you provide, the more closely your generated apps will satisfy your expectations. If you leave any decision up to the agent, it may do something other than you intend. If you tell it exactly what to do, and build your apps by iterating in very small steps, completing one functionality in the app at a time, you'll typically have the best possible experience.

It's common for prompts to require many paragraphs of explanation, just to build a small feature. If you explain the visual layout, the human interactions you app's user will perform, the data involved (what values, files and other info should go in, and what values, files and info should come out of the app), and the specific rules/logic the app should follow to process that data, you'll typically get the results you ask for.

Be specific and spend time writing prompts - you'll get much better as you get more experience working with your LLM (each LLM has its own quirks). There are plenty of tutorials about 'prompt engineering' available online, to help you improve that critical skill.

Be aware that it's very important for your agent to use programming languages and tools that are well known. If you've never learned anything about programming languages, Python and JavaScript will cover most of the sorts of useful applications you'll want to build, and most LLMs are absolute whizzes with those languages, and with 'frameworks' such as Flask which are built from those languages.

Flask is a collection of tools which work together as a single coordinated system (a 'framework'), for building full stack web apps that you want people to access with a browser. It's lightweight, fast and easy to install, interoperable with other technologies, and very well known, so other developers will understand right away how to work with Flask apps you create. Your flask apps will run immediately on any modern desktop or mobile device that has a web browser (Windows, Mac, Linux, Android, iOS, Chromebook, gaming devices, etc.), without having to be accepted/published in an app store (that process is many times more complicated, and not appropriate for personal apps that you may want to update regularly).

If you're building simple games and media heavy apps that don't require a backend server, ask Pi to create your app as a single HTML file. Single HTML files are portable between all modern devices and operating systems, and they require no installation whatsoever. You can email them, copy them to Google Docs, publish them to the world on a simple web server, and/or share them via any storage device. The HTML/CSS/JS code which can be included in a single .html file is the most ubiquitous way front-end layouts are built in modern applications of all sorts (even for impressive 3D, virtual reality, and other UI heavy applications).

All the game examples in this tutorial are single HTML files. All the server apps (the forum examples and multi-user business management apps which save data into a database) were created using the Python Flask framework.

If you have no idea what language, framework, or tools to use, ask Pi what's best, or just let it work on its own. It will generally make good decisions without your help, but you're always free to specify your tool preferences.

Try inexpensive and free models

Be very careful not to use an expensive model like Claude initially, until you have a better sense of how many tokens are burned by completing various tasks.

Deepseek-v4-pro will do a great job completing nearly any task you request, and it costs only $0.43 US (43 cents) per million input tokens and $0.87 per million output tokens. The model named Claude Opus 4.6 Fast on the other hand, costs $30/M for input tokens $150/M for output tokens, and openai/gpt-5.5-pro costs $30/M for input tokens $180/M for output tokens - so those models can end up costing more than 200x as much!

The truth is, many (most) tasks can be completed quickly & effectively using very inexpensive models. Just type /model into the Pi command line, and be sure to try the following:

  • deepseek/deepseek-v4-pro ($0.435/M input tokens $0.87/M output tokens) this is the default model you should try first, for most coding and agentic tasks
  • deepseek/deepseek-v4-flash ($0.098/M input tokens $0.196/M output tokens) this is a lighter weight, less expensive and faster performing model made by Deepseek, good for lots of basic tasks and some basic software development. Super inexpensive to use (less than 1/4 the price of v4-pro).
  • xiaomi/mimo-v2.5 ($0.14/M input tokens $0.28/M output tokens) another inexpensive model which is multimodal (can take images & videos as input), excels at front end design, and has 1 million token context length.
  • tencent/hy3:free ($0.14/M input tokens $0.58/M output tokens) this is ridiculously inexpensive for a very capable model. CURRENTLY FREE UNTIL JULY 21, 2026
  • deepseek/deepseek-v3.2 ($0.252/M input tokens $0.378/M output tokens) this is the older flagship version of deepseek, still very capable, and a great buy
  • minimax/minimax-m3 ($0.30/M input tokens $1.20/M output tokens) an open source model which has near frontier-level multimodal performance & 1 million token context length
  • moonshotai/kimi-k2.6 ($0.74/M input tokens $3.49/M output tokens) a world class multi-modal open source model
  • xiaomi/mimo-v2.5-pro ($1/M input tokens $3/M output tokens) another world class inexpensive multi-modal open model
  • z-ai/glm-5.2 ($1.20/M input tokens $4.10/M output tokens) currently the most powerful open source model for coding and software development
  • nex-agi/nex-n2-pro:free (FREE) this is a very powerful model, currently completely FREE on Openrouter, for the time being
  • google/gemini-3.1-flash-lite-preview ($0.25/M input tokens $1.50/M output tokens) this may be the FASTEST model available, plus it's really cheap and quite smart
  • google/gemini-3-flash-preview ($0.50/M input tokens $3/M output tokens) (a more powerful and more expensive version of google's gemini flash)
  • qwen/qwen3.6-plus ($0.325/M input tokens $1.95/M output tokens)
  • qwen/qwen3.6-flash ($0.25/M input tokens $1.50/M output tokens) another favorite - qwen has a wide variety of versions which are worth testing and using
  • qwen/qwen3.7-plus ($0.40/M input tokens $1.60/M output tokens)
  • qwen/qwen3.7-max ($1.25/M input tokens $3.75/M output tokens)
  • qwen/qwen3.6-27b ($0.2885/M input tokens $3.17/M output tokens) interesting mostly because it's possible to self host on high end consumer hardware. Try this one on the Openrouter API before you dive into buying any hardware to do AI on a home computer - it's about as good as LLMs get on consumer GPUs.
  • qwen/qwen3.5-35b-a3b ($0.14/M input tokens $1/M output tokens) this model is currently the best for low end consumer hardware. You can run it at home with GPUs that only have 16GB VRAM.
  • inclusionai/ling-2.6-flash ($0.08/M input tokens $0.24/M output tokens) another very inexpensive model
  • x-ai/grok-4-fast ($0.20/M input tokens $0.50/M output tokens)
  • stepfun/step-3.7-flash ($0.20/M input tokens $1.15/M output tokens) this model is capable and can be self-hosted on high end consumer GPUs
  • bytedance-seed/seed-2.0-lite ($0.25/M input tokens $2/M output tokens)
  • x-ai/grok-4.3 ($1.25/M input tokens $2.50/M output tokens) - this one can get pricey

You can see a list of all available models and their price per million token costs at:

https://openrouter.ai/models

(that URL, BTW, is a great place to keep up with all the new AI models being released by companies around the world).

You can track the exact cost of all your token usage at:

https://openrouter.ai/activity

Here are a few quick demo apps from some of these less expensive models. The example from Deepseek 3.2 cost $.09. The example from Mimo2.5 Pro cost $.08. The Hy3 example was created entirely for free (use those free models on Openrouter to the fullest!). Notice the high creativity and technical quality of even the older Deepseek model's output - that model costs far less to use than the newest Deepseek 4 Pro:

Whenever an inexpensive model gets stuck completing any particular goal, you can always switch to another model (even in the same Pi session), to see if the other model can figure out a better solution.

Switching models is just like adding an additional knowledgeable colleague to a team - one who has a different set of training experiences, perspectives, strengths, and skills, to help with a problem.

Notice how each model's take on the 3D space invaders games above was fundamentally different. Those are just simple game examples, but the same sort of fresh perspective is applied when you work out more challenging engineering tasks with alternate models.

Hacking away at a problem in round-robin iterations with different models, is one of the best techniques you'll find, to progress forward when one model's development efforts get muddled. Pi makes it so easy to switch AIs, without having to change anything else about a project configuration. Just run the /model command and let another brain have a go at fixing your issues.

Getting to know which model to use for a particular type of job, and how to best interact with each model, is a very important understanding to cultivate.

Here are a few more examples made by the Deepseek-v4-flash model - its really amazing how inexpensive and capable that model is!:

An interesting case study in which a variety of different LLMs were used to create simple graphic and text based games in the old Rebol2 programming language, is available here:

https://com-pute.com/nick/rebol_games_by_open_source_LLMs.zip

The Rebol R2 interpreter needed to run those code examples is available here:

https://www.rebol.com/downloads.html

That case study is explained in more detail in this forum topic:

https://aibynick.com/thread/52

Save your work

Ask your agent to periodically save your project, including all code and everything required to configure it on another machine, in a single zip file.

You can also ask Pi to install Git and use it to periodically save each version of any app you create. Git is the version management system most universally used by developers to explore different development directions ('branches') and revert to any previous version, merge features from multiple branches, etc.

Tell your agent to use TOOLS

AI agents are great at writing software. Leveraging that capability is perhaps the most important thing to instill in your understanding about improving AI workflows.

For example, you can tell an LLM to solve a Towers of Hanoi game, and it may be able to solve a setup that involves a dozen pieces. Anything bigger than that, and it will lose track of all the steps it's taken along the way, to solve the game - in the same way a human would. LLMs only have a limited context of data they can work with at one time. Exceed that context and they lose sight of the information they need to pay attention to.

If you instead tell the LLM to write a generalized program to solve Towers of Hanoi games, it will be able to use that program as a tool to solve games which involve millions of pieces. That's a enormous improvement in capability.

The same is true for many different classes of computing challenges:

  • Tell an AI to remember 10 million names & phone number pairs, and even the biggest LLM will fail. Tell that same AI to store the names and numbers into a database & write SQL code to query the database, and it will perfectly return any of 100s of billions of names & phone number pairs, every time.

  • Tell an AI to find trends in statistical data, and it will likely be capable of reasoning through some useful analysis of a small data set - but it may return a slightly different unstructured answer every time. Instead, tell it to write Python code to perform the same analysis, and it will be able to slice and dice datasets that are many orders of magnitude larger - and the results will be perfectly consistent (plus, you can ask it to produce charts, graphs, and computations via code too...).

  • Tell ChatGPT to count to 1000, and it will choose not to, because OpenAI has trained its models not to waste millions of dollars of tokens doing silly things like that. Instead, tell it to write a little JavaScript program to count to 10 million, and run that app in the browser. It will get that done in a few seconds - plus, you could ask it to build an app that speaks in different voices, has adjustable speed controls, etc.

  • Ask Pi to save your current session to an HTML file, and it may take a minute to work on that task, burning many tokens along the way. Instead, ask it once to write a program that saves your sessions to an HTML file, and then in the future tell it to use that program to save your sessions to HTML, and it will forever be able to perform that task instantly, and only burn the few tokens it takes to launch the app (the app's execution, as complex as it might be, doesn't burn any generative AI tokens at all). You build the tool once, and your AI will forever be more capable and efficient at that task.

  • Tell an LLM to search through millions of Word and PDF documents for a bit of information, and you could burn 10s of millions of tokens every time that task is performed. Instead, tell the agent to summarize each new document, one time, and store an index of all the information it contains, in a structured format, then build a tool to use that index to find summaries, and drill down only to the specific details which need to be read in a document. The system will perform many times faster doing that generative work, and use only a tiny fraction of the tokens, to accomplish the same task.

  • Ask an LLM about current events today, and it will tell you that it only knows about the history which occurred before its training date cutoff. Instead, tell it to use a search tool, and it will go out on the web to summarize currently available information from relevant news sites, search engines, and other sources (most mainstream chatbots do this automatically these days). Follow the same approach whenever you need information, for example, about how to use a product you on. Instead of relying on whatever data may have been in an LLM's pre-training corpora about that product, have the LLM go out and research user manuals for that specific item, look up posts on the manufacturer's support forums, etc., and it will provide much more detailed, specific, correct results about how to use the product.

  • Ask your agent to interact with a web site, and it may not be able to do anything more than summarize the front page content. Tell it to write Playwright code (that's a programming framework available at https://playwright.dev which uses code to interact with web sites) and it'll be able to control every button, UI widget, and interactive navigation path on the site.

That same fundamental approach: 'use tools', 'write code', 'build an app', 'use a database', etc., can be applied to solving virtually every sort of deterministic computing problem which you might attempt to accomplish with an AI agent.

Always keep in mind that the one thing current LLMs can do better and faster than almost any human, is write application code. The apps which get created with that code can be used as reliable and efficient tools to accomplish all sorts of goals which the LLM couldn't achieve otherwise.

To be clear, you don't need to know how to write the code to create useful tools yourself. It's just important guide your agent to write and use Python code and an SQLite database, for example, to manage vast amounts of data. Tell it to use JavaScript to build user interfaces and complex data visualizations. Tell it to use Playwright to interact with web sites. Just use those words.

Most LLMs can understand and reason about how to solve virtually any problem you can imagine, with code. That's the most potent superpower every modern AI has been trained to make use of. You just need to steer your AI model to consider using that capability in many cases, and learn how to use your agent to build reusable software tools, instead of just relying on its native brute force reasoning skills and knowledge, whenever possible.

Repetitive workflows of any sort can typically be aided by the use of some generated tool. If your goal is to build content to post on social media, for example, don't just plan to work with an AI agent to manually generate each individual post. Instead, architect a repeatable workflow recipe which enables the agent to consume media, and then generate endless posts from the same basic patterns inherent in the generalizable creative approach you follow, to output the valuable content in that media.

Perhaps that process could be helped, for example, by any application which resizes batches of images to a consistent pixel height and extracts text content from each image. Perhaps you might then want to insert those images into a consistently animated layout, and perhaps you'd like to create a consistent avatar to speak in AI generated videos about those animated layouts. You can have your agent build apps to perform those portions of your workflow. Those sorts of apps will help you generate a much greater volume of material, with more consistent, professional looking end results.

If you're not sure how to conceive of buildings tools, how to word prompts to Pi, or how to approach solving any problem, just ask Pi to help you formulate sensible questions. Treat working with Pi + your LLM model just like working with a person who has broad knowledge and technical skill in a given discipline. Ask it if a tool can be built, to better achieve your workflow. You'll be amazed at how it can lead you towards achieving any goal, how it can help build tools along the way, if you just ask.

You never need to feel stuck when working with an AI agent. Talk to Pi if you have any questions about how it can help you accomplish anything in the digital world. And never forget to use multiple models to chip away at a problem. Ask your smartest available model to create prompts to guide the work of other models. Ask each model to review and improve upon the work of other models.

Each LLM brain will approach every situation differently, and will have different useful perspective about any given situation. Use that varied perspective, along with each model's particular strengths and skills, to build better tools and repeatable workflows. Use inexpensive models to get routine utility work completed, and use more expensive models whenever a less expensive models gets stuck completing a challenging task.

Pi isn't just for building apps - you can use it to accomplish virtually any useful task.

Ask Pi to get any sort of general work done, which might take you time to complete on your computer:

  • find information in files and perform calculations/computations on any data you have access to
  • install and manage apps, services, and configuration settings on your computer
  • manage any sort of third party account you give it credentials to access
  • prepare and edit documents of any sort (spreadsheets, presentations, articles, etc.)
  • proofread any creative and functional work before you publish it, and have Pi perform the work of actually publishing those materials
  • complete learning and research goals, with all the materials you need, synthesized directly on your PC
  • communicate more efficiently with people via any channel you prefer: email, texts, social media, voice, etc. (organize how you sort, respond to, and automate interactions with groups & individuals)
  • write software to edit photos, create videos, and manipulate music + other content
  • organize all your files and digital clutter
  • improve every sort of business operation, including:
    • scheduling
    • billing
    • inventory management
    • the generation of marketing materials, branding and graphic design materials, etc.
    • web site creation, and the generation of content for those sites

Be aware that the best solution to many common issues is often to create a little app to achieve some particular goal.

Since software development can now be accomplished so easily, quickly, and inexpensively with agents like Pi, an entire new paradigm has begun to emerge, in terms of how problems can be better solved with computing technology. You can build whole collections of perfectly customized apps which talk with one another, to simplify entire classes of real life work, in exactly the ways you prescribe.

Read the docs

See the official Pi documentation to learn more about how to use all of Pi's features:

https://pi.dev/docs/latest/usage

A great YouTube tutorial video about Pi is available here:

https://www.youtube.com/watch?v=BZ0w0JhPQ9o

If you're a developer working on a team, be sure to read this post about using Pi with Git:

https://aibynick.com/thread/30

Try other agents

There are many other agents (AI assistant apps) similar to Pi:

Many of those alternative agent apps have even more features than Pi, at the expense of some bloat, complex setup, higher token usage fees, etc. Some are focused on software development and/or other specific classes of tasks.

Many agent systems enable the ability to interact via text messaging, Telegram, Whatsapp, Signal, and even real time voice calls - so you can chat with the agent just like you would a human, and ask it to get work done for you, no matter where you're located.

I personally prefer Pi, Hermes, Picoclaw, Nanobot, and Nullclaw for various purposes:

  • Pi is lightweight and malleable - it can be extended with more features (in fact, it's what the popular Openclaw agent was built upon).
  • Hermes has many built-in features, plus it builds skills automatically as you use it (i.e., it builds recipes about how to accomplish goals which you've previously solved with it - it automatically builds its own reusable tools, based on the experiences and challenges you work through with it).
  • Picoclaw is perhaps the easiest full-featured agent to set up, for non-technical users (it doesn't require an command line use at all). Picoclaw is particularly light weight, it requires no installation (just unzip the package and run PicoClaw launcher), and it runs on virtually any sort of computer - there's even an APK version which can run directly on your Android phone or tablet. Every setting in Picoclaw, including your choice of common LLM providers (OpenAI, Anthropic, Google, Deepseek, Openrouter, etc.), communication channels (Telegram, Discord, Whatsapp, etc.), skill configurations, etc., can all be edited entirely by clicking simple UI menu selections.
  • Nanobot is a built entirely from a simple hackable Python code base, and it has a nice mix of essential assistant features (messaging, scheduling, spawned jobs, memories, etc.).
  • Nullclaw is utterly tiny, with virtually no installation dependencies - great for quick one-off installations to accomplish utility tasks.
  • Openclaw is currently the most popular agent, so it has the largest community support. That can be useful when you want to implement a specialized agentic capability, and somewhere in the world, someone has already solved your use case with Openclaw. There are so many features built into Openclaw, the capabilities can be head spinning.

It takes some time to learn how to use all the individual features available in each app, but keep in mind that you can always ask Pi about how to use them, have Pi install them for you, help you research other agentic systems that are available, etc., and then use each new agent to do the same.

Try Jan

If you're going to do any work with Openrouter on your local computer, it's also worth installing the Jan AI app:

https://www.jan.ai

Jan lets you quickly connect to any LLM in your Openrouter account and chat with it. Using Jan is like having your own local ChatGPT interface, which can switch immediately between any of the hundreds of AI models available on Openrouter. This is particularly useful when you want to try new models, or when you want to use any of the free models which get released regularly on Openrouter. Take advantage of all those free tokens!

Using local LLM models

The Jan app also enables the ability to run local AI model APIs directly on your own computer, if you have local GPU hardware installed. You can even download some very small models which run entirely on the normal CPU inside any modern PC - although even the smallest models will run very slowly on a CPU, and those small models won't be very smart or reliable. It's still interesting to see how tiny models work, without needing to use GPUs in a data center, or even have Internet access to do AI work.

Some other popular apps which are used to run local AI inference include:

You don't really need to know much about LLMs or any have AI research background to use these apps. Just download and install them. They're free and simple to use.

You will need to buy GPU hardware, however, if you want to use these apps for any practical purpose.

The company which makes Ollama, also provides remotely hosted API services, similar to what you get from Openrouter. Those services from Ollama are offered in a subscription plan (you pay for a rate-limited monthly volume of use, instead of per-token).

It's nice to be able to run both free open-source models directly on your local GPU, and also use remotely hosted models in a data center, all in one application. Doing that is also possible with the Jan app - Ollama is just a slightly more complex system, with more features and a bigger surrounding ecosystem, which is heavier to install and a bit more complicated to learn how to use. Jan is lighter weight, it plugs right into the Openrouter API (just paste in your API key), and it lets you import models that you've previously downloaded with Openrouter and LM Studio. The Jan installer is 50Mb, where the Ollama installer is 1.5 Gb (1500Mb).

The models you choose to use make a tremendous difference in your local hosting experience

The best free open-source models that can currently run on the least expensive local GPU hardware are:

The following demo apps were created using those models, on a laptop with an inexpensive Nvidia RTX3080ti GPU that has only 16GB of VRAM (no Openrouter/datacenter processing was used to create these apps - they were created with Pi, using an LLM that ran entirely on the laptop GPU):

Buying GPU hardware

If you're really interested in running AI tasks entirely on a local computer (without any need for Openrouter or other rented AI services), then you'll want to purchase a computer with GPU hardware. One of the least expensive ways to do this is with a machine that has an AMD Strix Halo processor, such as:

https://www.amazon.com/gp/product/B0DW238TXK

or with a machine powered by the Nvidia GB10 chip, such as:

https://www.amazon.com/gp/product/B0G1MQYHRD

Nvidia hardware tends to excel at all common AI tasks, and their 'CUDA' framework is supported by special types of AI models that are used, for example, to generate image, video, and audio.

Apple Mac Studio machines with an M3 Ultra chip and 512Gb of RAM are a popular choice for running very large LLMs. Those machines use very little power compared to the class of machines used in data centers, but they currently cost $20,000-$30,000.

You can also purchase multiple GPUs and put them in a tower or a rack mounted computer. The Nvidia RTX3090, RTX3060, and RTX5060Ti models are commonly used to achieve best price/performance in consumer hardware.

Another way to run larger, smarter, more knowledgeable LLMs at home is to 'cluster' together 2 or more less powerful machines. Clustering requires extremely fast network connections, but when set up correctly, enables you to combine the processing power and VRAM (GPU memory) in both machines, to run much more capable models. Search for the term 'cluster' on this forum, to learn more.

The examples below were created on a single local Strix Halo machine, using the same qwen3.6-35b-a3b model as above, but with different prompts. The quality of the output is equivalent to the 3080ti laptop used above, but the Strix Halo machine produced these examples much more quickly:

Diving deeper into the topic of locally hosted LLMs is beyond the scope of this quick-start tutorial, but it should certainly be on your radar if you want to understand AI tools more completely.

An installation guide which you can use to run local LLMs in LM Studio, together with Pi, is available at the link below. This is the exact configuration used to build all the example apps above, on both the Strix Halo and 3080ti machines:

https://com-pute.com/nick/install_pi_agent_windows_and_linux.txt

If you want to self-host LLM models, be sure to take a look at the hardware and other topics on this forum:

https://aibynick.com/category/4

There are many other ways to run AI models, and to move into research/development class tooling

If you need to run heavy AI models, but require privacy, access, control and/or performance which can't be guaranteed by Openrouter, Ollama, and similar services, or if you want to build your own models - especially if you're in a position where you need huge GPU processing power, but it doesn't make sense to purchase extremely expensive equipment (which often requires more electricity than is available on typical residential circuits), then there are plenty of services which rent compute that's specially tailored for AI model hosting and research/development:

  • Vast.io
  • Runpod.io
  • Lambda.ai
  • Digitalocean
  • Amazon EC2 UltraClusters
  • CoreWeave
  • Google Compute Engine
  • IBM Cloud GPU Server
  • Thunder Compute

Those and many others available, all with different pricing schemes, and everything from datacenter class dedicated hardware contracts, to pay-by-the minute rentable consumer grade GPUs available. It's a long road to understand every option available, but this is another topic that should be on your radar, as you dive deeper into building AI solutions.

For the moment, consider using Pi and other agents to help with any work you do on a computer

Even if you're only just starting out learning to use AI, gaining some skill with a few of the most powerful tools, such as Pi, can instantly and dramatically change how you use technology.

Using Pi is like giving your AI chatbot hands to type on the keyboard of your local computer - you just tell it what task you want completed, and it goes off working on your computer. Pi can create, read, update and delete files, connect to any service you give it credentials to access, look up information on the Internet, and plan how to use any resources available on your computer, to complete any work you request.

Once you get to know Pi and other agents like Hermes, Openclaw, Nullclaw, Nanobot, etc., you'll likely find yourself naturally using them to help accomplish all sorts of work you do with computers. These agent applications really can do the work that would typically be handed to a hired personal assistant or a tech employee who's job it would be to help you get things done in the digital world.

When you begin to see all the ways AI agents can automate and speed up almost any sort of digital task, it's easy for them to become the centerpiece of your digital activities.

You could choose, for example, to give your bot your credit card information, ask it to research all of the product choices available, provide a report about the items which best fit your needs, and then have it log into Amazon to purchase your chosen item(s). And if you've set up a text message channel with your bot, you could have that entire interaction with it, just like you'd have a conversation with a human. You don't even need to be near a computer.

I'm absolutely not suggesting that you use Pi to do anything like that, which could potentially lead to mistakes and financial losses, but that scenario illustrates just the sorts of capabilities current AI agents already have.

Just start to imagine what you could do if you had a team of really knowledgeable tech assistants and software developers at your command, and realize that tools like Pi can actually do what such a team can do (and more), for pennies. Follow the install instructions above, dive in, and you'll begin to see how this little command line tool can actually change the course of real world activities in your life.

WARNINGS

Be very careful not to ask Pi, or any other API based AI tool, to do anything that could delete any critical files, share any private data, or perform any other operation which could potentially cause you trouble. Pi and other agents hand over basically full operational control of your computer, to the LLM which you connect it to (Claude, ChatGPT, Gemini, Grok, Deepseek, etc.). Always keep in mind that Pi enables your LLM to do virtually anything a person can do on your computer. That gives Pi great powers to complete work on your behalf, but it also opens up the possibility for significant security breach and data loss threats. Be aware that any text you type into Pi, and any files which Pi reads, can potentially be seen by the company which provides your LLM model API. That data could be used to train their future models, and therefore could show up in future answers which the LLM provides to other future users! So always guard your privacy carefully when working with Pi, and/or any other local AI agent system.

For that reason, the following disclaimer needs to be included below - please be careful, back up your data regularly, and avoid sharing private info on any machine where you run an AI agent of any sort

IMPORTANT LEGAL DISCLAIMER: READ BEFORE PROCEEDING

THE INFORMATION AND INSTRUCTIONS PROVIDED HEREIN ARE FOR EDUCATIONAL PURPOSES ONLY. THE AUTHOR PROVIDES THIS CONTENT "AS IS" AND "WITH ALL FAULTS." THE AUTHOR DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS CONFIGURATION, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. USERS ASSUME ALL RISK FOR SYSTEM DAMAGE, DATA LOSS, OR SECURITY VULNERABILITIES RESULTING FROM THE USE OF THESE INSTRUCTIONS.

History
Nick Antonaccio
Nick AntonaccioAdmin
May 01, 2026 at 16:01 (edited, 19 revisions)
#2

Deploying to a VPS server

When you're ready to take the next step and set up your own server to deliver software to the world, create a VPS account with any hosting company, such as:

Plan to spend ~$50ish per year to start.

You'll need to learn how to use SSH and some basics about how the Linux operating system works:

https://com-pute.com/nick/linux_server_basics.txt

Log into your VPS server via SSH, install NodeJS, create a tmux session to run Pi, and install it just like you did on your local computer:

npm install -g @mariozechner/pi-coding-agent

And/or try installing the Hermes agent - it's just another, even more powerful alternative to Pi:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

Try connecting Pi, Hermes or any other agent software you use, to other models at Openrouter such as google/gemini-3.1-flash-lite-preview. Getting to know the particular strengths, weaknesses, performance/speed, capabilities, and operating cost trade-offs of each of the most popular LLM models is a huge part of learning to get 'AI' work done more effectively.

Get a domain name and set up HTTPS encryption

At some point, you'll likely want to buy a domain name (.com URL) from any registrar (Godaddy, Namecheap, Tucows), for your server. You'll need to set the DNS A record of your domain name to point to the IP address of your VPS server, and set up HTTPS termination, most often using a program called Caddy (using the free letsencrypt service).

Ask Google and/or GPT for help with any of the required steps. These things can take some time to learn, and may seem complex until you've done them a few times.

Be aware that you'll need to learn a lot about security and maintenance to run a server

That goal is a long road. You'll never stop learning about how to establish and follow best practices. Be sure to learn about HIPAA, PCI, GDPR, CCPA and other laws & compliance obligations you're required to satisfy, especially if you ever deal with private Protected Health Information (PHI), financial information, or any other sensitive data on your server. At very least, learn how to satisfy SOC 2 and ISO 27001 standards for any software you create & publish publicly. That includes setting up proper controls for network security, server configurations, access management, incident response, code review, version control, penetration testing, audit logging, and more. You can potentially get fined huge amounts of money if you ever disobey privacy regulations, and ignorance about existing laws & compliance obligations is never an excuse which will save you in court. There's a huge world of ruthless bad actors out there who don't care one bit if they wreak utter havoc on your life, just to make a few bucks - so do your due diligence to protect yourself and the users of any system you create!

History
Nick Antonaccio
Nick AntonaccioAdmin
Jul 13, 2026 at 18:33 (edited, 7 revisions)
#3

This tutorial may be helpful if you're just beginning to learn about AI:

And this tutorial which ChatGPT created may also be helpful:

https://com-pute.com/nick/AI_tutorial_GPT.txt

I had Fable build out long, short, and summarized versions:

I had NotebookLM create a very basic synopsis video of the Fable version of the tutorial:

https://youtu.be/uqFD3XQEk6s

History
Nick Antonaccio
Nick AntonaccioAdmin
May 01, 2026 at 20:55 (edited, 5 revisions)
#4

AI agents like Pi are great, but for all my serious professional software development work, I still use a tried and true workflow which requires only ChatGPT, and doesn't need any software to be installed on my local computer at all:

My ChatGPT zip file development workflow: https://aibynick.com/thread/3

The article below explains a bit about what it's been like to be a software developer since LLMs started getting good at writing code (we're still needed!). This may also be an interesting topic if you're wondering how to progress from building little vibe coded apps, to large pieces of production software:

The the difference between vibe coding and software engineering: https://aibynick.com/thread/28

History
Nick Antonaccio
Nick AntonaccioAdmin
Jul 08, 2026 at 21:04 (edited, 14 revisions)
#5

Here's a quick run-thru of how to upload project zip files for flask apps which you've created on a local machine, to a Linux VPS:

On your VPS server, create a new tmux session & python environment:

tmux new -s myapp
python3 -m venv myapp
cd myapp
source bin/activate

On your local computer, send your project file to the server:

scp -P7822 myapp.zip username@yourserverdomain:~/myapp

(select 'yes' if prompted to save a fingerprint the 1st time you SCP to a server)

enter your password when prompted

(BTW, I keep text files available with these upload commands and the password for each project/server, in each project zip file.)

On your VPS server, in the folder created above: unzip, edit and run your app:

ls
unzip -o myapp.zip
# if your project code is contained in a subfolder in the zip file:
cd myappfolder
# install all the python libraries required to run your app (only needed once per environment)
pip install -r requirements.txt
# edit:  host='0.0.0.0', port=9999 (default is 5000 for flask) in app.run():
nano app.py
# allow the port above in your firewall, if you have ufw installed:
ufw allow 5000
# the file which starts your app is usually app.py or run.py 
python3 app.py

# To stop a running flask app, within a tmux session:
CTRL C
# To detach your current tmux session
CTRL B
# To re-attach an existing tmux session:
tmux a -t myapp

If you want to set up https and subdomains with caddy:

tmux a -t caddy  # if you're running caddy in a session
nano /etc/caddy/Caddyfile
add a section as follows, for each app port: 

yoursubdomain.yourserverdomain.com {
  reverse_proxy localhost:5000
}

Then reload caddy:

sudo systemctl reload caddy

# or, if you're running caddy in a docker container:
#  sudo docker exec caddy caddy reload --config /etc/caddy/Caddyfile

To get a local app packaged as a zip file, ready to install using the steps above, a prompt for Pi may be something like:


There is currently a flask app running at http://127.0.0.1:5006/ on this machine.  Please provide a zip file with all the code, config settings, and everything else required to install this application on another server.

If you've built the app on one VPS and want to prepare to move it to another server, add this following line to the prompt:


Please serve this zip file over http (ensure the port is open in ufw).
History
Nick Antonaccio
Nick AntonaccioAdmin
Jul 03, 2026 at 23:24
#6

NOTE: If Pi has any trouble using the 'bash' tool in Windows, download and install Git from https://git-scm.com/install/windows - it installs Git Bash by default, and Pi can use it for Bash commands.

Nick Antonaccio
Nick AntonaccioAdmin
Jul 04, 2026 at 01:55
#7

Be sure to try cline-pass as alternative to OpenRouter. It's a less expensive LLM API service with very fast performance. See https://aibynick.com/thread/51 .

Please login to post a reply.

© 2026 AI By Nick.