Pi-Mono על Smart AIPI: הדרך הזולה ביותר להריץ coding agent רזה — עם Grill-Me, Superpowers ו-Caveman

לתנועת ה-lean-agent יש דגל מוביל. Pi-Mono הוא ה-monorepo מאחורי pi, coding harness לטרמינל של Mario Zechner (יוצר libGDX) שמפשיט coding agent אל היסודות ומעביר את כל השאר ל-extensions. כפי ש-Zechner ניסח זאת בהרצאת Mastra שלו "I Hated Every Coding Agent, So I Built My Own": harnesses מבוססים הם חלליות עם 80% מהפונקציונליות שרוב המפתחים לעולם לא נוגעים בה, ו-system prompts שלהם משתנים בכל גרסה — מה ששובר את תהליכי העבודה האישיים שבניתם בקפידה מעליהם.

התגובה של Pi היא מינימליזם רדיקלי: ארבעה כלים, מצב YOLO מלא, בלי batteries included. יכולת hackability לפני completeness. על ה-endpoint של Smart AIPI שתומך ב-OpenAI ומבוסס pay-as-you-go, המינימליזם הזה מתרגם ישירות ל-setup הזול ביותר של coding agent רציני שנמצא היום בשוק.

מה Pi-Mono באמת הוא

Pi-mono הוא ה-monorepo (github.com/badlogic/pi-mono, עם mirror ב-earendil-works/pi); קובץ ה-CLI הוא פשוט pi. ה-repo מתפצל לכמה packages ממוקדים:

• pi-agent-core — ה-runtime: קריאות ל-tool, state, ולולאת ה-agent עצמה.
• pi-ai — ספריית provider מאוחדת שמדברת עם Anthropic, OpenAI-compatible, Bedrock, Vertex, Mistral, Groq, Cerebras, xAI, DeepSeek, OpenRouter, Hugging Face, Ollama, ועוד בערך תריסר אחרים. חשוב במיוחד: היא יכולה לכתוב מחדש context כדי להחליף provider באמצע session בלי לאבד state.
• pi-tui — UI לטרמינל עם differential rendering.
• pi-coding-agent — ה-CLI שמחבר את החלקים יחד עבור המשתמש.

משטח הכלים ברירת המחדל הוא ארבעה כלים, וזהו:

כל דבר מעבר לזה — subagents, plan mode, permission gates, MCP servers, sandboxing — חי ב-pi-skills או ב-extensions של צד שלישי, כ-opt-in. Pi רץ כברירת מחדל ב-full YOLO mode: בלי permission prompts, עם filesystem ו-shell ללא הגבלה. זו בחירה מכוונת. אם אתם רוצים safety rails, אתם מתקינים אותן.

למה Pi-Mono ו-Smart AIPI הם התאמה מושלמת

ספריית pi-ai של Pi מתייחסת לכל provider כאל endpoint בצורת OpenAI או Anthropic מאחורי interface אחיד. ה-gateway של Smart AIPI חושף את כל Surface של OpenAI — chat, responses, embeddings, images, audio, anthropic-shaped messages — דרך base URL יחיד עם API key יחיד. שני העיצובים משתלבים בצורה נקייה:

• מפתח אחד, כל המודלים. אותו Smart AIPI API key נותן לכם GPT-5.5, GPT-5.4, GPT-5.4-mini, GPT-5.3-codex, GPT-Image-2, וניתוב ל-Claude תואם Anthropic — ו-Pi יכול לעבור ביניהם באמצע session.
• תמחור pay-as-you-go. בלי subscription, בלי quota, בלי throttle. משלמים על ה-tokens שבאמת חישבתם. ה-system prompt הזעיר של Pi אומר שכל turn משלם פחות על context קבוע מאשר harness עמוס תכונות.
• Prompt cache מקצה לקצה. Smart AIPI שומר את ה-prompt-cache key של OpenAI בדיוק כפי שהוא דרך ה-gateway, כך שה-repo + agents.md + history נשארים ב-cache לאורך sessions ארוכים. שיעורי cache hit בעולם האמיתי הם 95–98%, מה שמוריד cached input ל-$0.125 ל-1M tokens — זול פי 10 מ-uncached.
• שמירת session דרך WebSocket. Sessions ארוכים של pi-mono נשארים על cache חם אחד במקום לשלם את מחיר input המלא בכל turn.

שלושת ה-skills שמשלימים את Pi-Mono

Pi במכוון לא שולח שום דבר עבור תכנון משימות, בלי methodology הנדסית דעתנית, ובלי שכבת compression ל-output. זו לא תקלה — זה כל העניין. הקהילה מילאה את כל שלושת הפערים עם skills קומפוזביליים שנכנסים לתוך Pi דרך תבנית ההפעלה /skill:name. שלושת ה-skills שכדאי להתקין כבר ביום הראשון:

1. Grill-Me — יצירת משימות עם High Reasoning

איפה: github.com/mattpocock/skills, מאת Matt Pocock.

Grill-me עושה בדיוק מה שהשם מרמז: המודל שואל אתכם על המשימה שוב ושוב עד שכל constraint ברור לחלוטין. אילו קבצים כלולים. מה criteria להצלחה. מקרי קצה. מה בדיוק אומר "done". בדרך כלל שלושה עד חמישה turns קצרים. אתם עונים; ה-skill מחזיר spec חד, בר-ביצוע.

המהלך הכלכלי הוא להריץ grill-me על high reasoning רק עבור שלב ה-spec — בדרך כלל שלושה עד חמישה turns קצרים — ואז לרדת ל-low reasoning עבור שלב הביצוע (30 עד 100 turns של עבודה זולה ומכנית). High reasoning משתלם במקום שבו הוא נושא משקל; low reasoning נושא את השאר. הלולאה של ארבעת הכלים של pi-mono מתאימה במיוחד לתבנית הזו כי אין שום דבר שמפריע: ברגע שה-spec נעול, למודל יש מסלול ברור דרך read/write/edit/bash כדי לסיים ולספק.

2. Superpowers — מתודולוגיית הנדסה כ-Skills

איפה: github.com/obra/superpowers, מאת Jesse Vincent.

Superpowers היא "מתודולוגיית פיתוח תוכנה מלאה עבור coding agents שלכם, שנבנתה על גבי סט של skills קומפוזביליים." תבניות ל-TDD, playbooks לבדיקת קוד, נהלי debugging, דפוסי refactoring, משמעת לניהול branches. זה תהליך ההנדסה המפורש ש-Pi בוחר לא לשלב ב-core.

היא גם harness-agnostic — אותו skill pack עובד ב-Claude Code, Cursor, Copilot CLI, Gemini, Codex, ו-Pi. מתקינים פעם אחת ולוקחים אותו אתכם בין harnesses. ה-skill loader של Pi, שמוכן ל-plug-and-play, מאפשר לכם להוסיף את כל המתודולוגיה מעל core מינימלי בלי לגעת בקוד המקור של pi.

3. Caveman — הקוטל של output tokens

איפה: ה-skills repo של Matt Pocock (קטגוריית productivity).

Caveman מעביר את ה-agent ל-ultra-compressed communication mode. מורידים מאמרים. מורידים filler. עונים בבולטים טלגרפיים. בלי English רשמי, בלי התנצלות, בלי preamble. הפחתה אמיתית מדווחת ב-tokens על turns עתירי-פרוזה היא בערך 75%.

למה זה שולט בחשבון: על GPT-5.5, output tokens עולים $7.50 ל-1M לעומת $0.125 ל-1M עבור cached input — יחס של 60×. דחיסת output היא הדבר הכי ממונף שאפשר לעשות לחשבון של coding agent. Grill-me + low reasoning כבר מקטינים output. Caveman דוחס את מה שנשאר. חברו את זה ל-cache של Smart AIPI, והעלות השולית של turn נוסף מתקרבת לרצפה של מעטפת החישוב של המודל.

סיפור העלות המצטברת

התמחור ב-Smart AIPI עבור GPT-5.5:

הצורה של turn ב-pi-mono על GPT-5.5 low reasoning, כשה-spec של grill-me כבר הושלם ו-caveman פעיל:

• Cached input prefix (repo + agents.md + history) — בדרך כלל bucket ה-tokens הגדול ביותר בכל turn — מחויב לפי cached rate, לא לפי uncached rate, בכל פעם שיש cache hit.
• New uncached input (תוצאות tools, הודעת המשתמש האחרונה) — בדרך כלל שבריר קטן מה-input, מחויב לפי התעריף המלא.
• Output — נדחס על ידי caveman, עם מינימום reasoning tokens כי המאמץ נמוך. זה סעיף החשבון שהכי כדאי להקטין כי הוא מחויב לפי התעריף הגבוה ביותר לכל token.

Pay-as-you-go אומר שמשלמים רק על מה שחישבתם, ושלושת המנופים האלה מצטברים. ה-dashboard שלכם יציג את מספרי העלות האמיתיים לכל turn עבור ה-repo וה-prompt shape שלכם — בלי cap, בלי throttle, בלי minimum חודשי.

החלפת provider באמצע session: ה-feature השקט של Pi

Pi-ai שומר ייצוג context נייד ויכול לכתוב אותו מחדש כדי להתאים לכל provider שאליו מכוונים כרגע. תרגום מעשי: כש-GPT-5.5 נתקע על ambiguity קשה, אפשר להשתמש ב-/model claude-sonnet-4.6 באמצע המשימה לחוות דעת שנייה בלי לאבד את השיחה. שני ה-endpoints יושבים מאחורי Smart AIPI API key יחיד — תשובות Claude תואמות Anthropic עוברות דרך /v1/messages, וזרימות תואמות OpenAI עוברות דרך /v1/responses (או /v1/chat/completions), ו-Pi מטפל בתרגום בשקיפות.

עבור refactors ארוכים ובעלי סיכון גבוה, התבנית הזו באמת שימושית: grill-me על GPT-5.5 high עבור ה-spec, GPT-5.5 low לביצוע, Claude Sonnet 4.6 עבור מעבר review ארכיטקטוני אחד, ואז חזרה ל-GPT-5.5 low כדי לסיים. harness אחד, API key אחד, חשבון אחד.

Setup ב-60 שניות

# 1. install pi
curl -fsSL https://pi.dev/install.sh | sh
# or:  npm install -g @earendil-works/pi-coding-agent

# 2. point at smart aipi
export OPENAI_BASE_URL=https://api.smartaipi.com/v1
export OPENAI_API_KEY=sk-your-smartaipi-key

# 3. run pi in your repo
cd ~/code/your-project
pi

# 4. inside pi, install skills
/skill:install matt-pocock/skills/grill-me
/skill:install obra/superpowers
/skill:install matt-pocock/skills/caveman

# 5. spec your task
/skill grill-me

# 6. drop to low reasoning and execute
/model gpt-5.5 --reasoning-effort low
/skill caveman

התחביר המדויק להתקנת skill תלוי ב-skill loader שאתם מריצים — בדקו את ה-README של כל repo של skill עבור ה-invocation הנוכחי. המבנה זהה: להכניס את תיקיית ה-skill ל-config שלכם ולהפעיל אותו.

למה Lean Agent + Lean API מצטברים

harnesses עשירים בתכונות טוענים system prompt גדול בכל turn, מריצים מעברי deliberation נוספים, ומוציאים הסברים מפורטים שהמשתמש לא ביקש. כל אחד מהדברים האלה הוא מס. Pi-mono מקטין את המס בצד של ה-harness (system prompt קטן, לולאת ארבעה כלים, בלי שכבת תכנון מנופחת); caveman + low reasoning מקטינים את הצד של המודל (output דחוס, מינימום reasoning tokens); Smart AIPI מקטין את צד ה-provider (input cached פי 10 זול יותר, בלי subscription floor). אף אחד מהם לבדו אינו win של 10×, אבל כשמכפילים אותם יחד הם משנים משמעותית את העלות של הפעלת פרויקט agentic ארוך.

ההשקפה של Pi — "להתאים את ה-agent ל-workflow שלכם, לא להפך" — משתלבת עם ההשקפה של Smart AIPI — "לשלם רק על מה שבאמת חישבתם." אם נמאס לכם מ-subscription caps או מלשלם על תכונות harness שאתם אף פעם לא נוגעים בהן, השילוב שווה אחר צהריים אחד של ניסיון. Sign up, צרו key, הגדירו OPENAI_BASE_URL, התקינו את pi, התקינו את שלושת ה-skills, וספקו משהו.

להתחיל — $5 חינם בהרשמה

1. הירשמו ב-smartaipi.com/signup (חינם $5, בלי כרטיס אשראי)
2. צרו API key ב-dashboard
3. התקינו את pi: curl -fsSL https://pi.dev/install.sh | sh
4. הגדירו OPENAI_BASE_URL=https://api.smartaipi.com/v1 ואת OPENAI_API_KEY למפתח החדש שלכם
5. התקינו את grill-me + caveman ואת superpowers
6. הריצו pi, הפעילו grill-me על המשימה הבאה שלכם ב-high reasoning, עברו ל-low + caveman, וסגרו אותה

אותו harness מינימליסטי שהייתם מריצים על subscription — עכשיו על מודל תמחור שמתרחב לפי מה שאתם באמת מחשבים, עם cache hit rate שהופך sessions ארוכים של agent כמעט לחינמיים.