Pie, a new open-source AI coding agent written entirely in Rust, has landed on GitHub as a terminal-native alternative to browser-based code assistants. The project emerged from the creator's need for a customizable runtime that could handle long-term automated tasks against local models—specifically DeepSeek V4 running on a personal machine. Rather than building yet another chat wrapper around an LLM API, Pie positions itself as a full-fledged agent runtime with features like slash commands, session persistence, MCP tool integration, and what might be its most interesting angle: triggers and cron jobs that let developers define automation directly in conversational terms.

Why Rust? Why Local?

The original pi project got a complete rewrite in Rust, likely for performance and memory safety when running extended agent sessions. But the real story here is the local-first philosophy baked into Pie's architecture. The developer needed something proactive—capable of running background tasks on a local model without constant human intervention. That meant supporting custom triggers (watching for file changes, polling conditions), scheduling with cron expressions, and crucially, keeping all that logic local rather than routing through external APIs. If you're sensitive to AI-generated code, the project notes upfront that most of Pie itself was written by AI—but that's increasingly true of the entire ecosystem.

Triggers: Natural Language Automation

Pie introduces a trigger system that converts plain-English requests into actionable automation rules. Statements like "when ~/build.done appears, run cargo test and show me the result" get parsed into persistent rules stored alongside session data. These triggers can fire based on local file checks (polling every 10 minutes by default), MCP server push notifications, or custom events. Actions execute in a separate sub-agent that inherits the parent model's tools and configuration but runs independently—trigger output gets written to audit logs rather than polluting conversation history unless you explicitly promote results back into chat with promote_to_chat=true. This separation is smart; it keeps automation from derailing your main workflow while still giving visibility when needed.

The Hub: Agents Talking to Each Other

Perhaps the most ambitious feature is Pie's built-in hub at pie.0xfefe.me, an MCP-based discovery and messaging layer for agents running on different machines. Instead of sharing API keys or exposing session data, agents exchange bounded notification summaries through a trust-gated system. First-contact senders can be accepted, blocked, or skipped entirely—decisions persist locally in hub-trust.json without logging raw payloads or tokens. The hub isn't just theoretical notification passing; it's designed for real multi-machine workflows where you might have an agent on a laptop monitoring one repo while another on a server handles builds and reports back.

Storage, Scheduling, and the CLI

Pie maintains state under ~/.pie/ with session transcripts in JSONL format (one file per project, keyed by working directory hash), cross-session memory as Markdown files that inject into future contexts, stored API credentials via /login commands, and MCP configuration supporting both user-global and project-local overrides. Cron jobs use standard 5-field expressions like */30 * * * * for time-based scheduling, with missed ticks skipped after downtime rather than backfilled. The CLI offers --resume for continuing sessions, --thinking to control reasoning effort levels (off through xhigh), image attachment via --image flag, and hooks for command/webhook lifecycle events documented in docs/hooks.md.

Key Takeaways

  • Pie targets developers who want local model support without surrendering their data to third-party APIs
  • Triggers and cron jobs convert natural language into persistent automation rules with sub-agent execution
  • The hub enables agent-to-agent communication without exposing credentials or session content
  • Rust rewrite suggests performance focus for long-running background tasks
  • MCP tool integration provides extensibility beyond built-in file/shell operations

The Bottom Line

Pie isn't trying to compete with Cursor or Copilot on polish—it's for hackers who want full control over their agent runtime and aren't afraid of running models locally. The hub concept alone is worth watching; if multi-agent workflows take off, having a lightweight discovery mechanism baked into your CLI could become standard practice. Whether you trust AI-generated code in production is your call—but the project's own genesis suggests the tools are finally good enough to bootstrap themselves.