Why I Built Podiom: A Project Layer for Local AI Agents

Marcus Schmidt — Thu, 06 Aug 2026 17:52:35 +0000

The problem: your project disappears between sessions

Claude Code and Codex are fantastic tools, but they're fundamentally session-oriented.

That's perfect for answering questions or making focused code changes. But once you start using agents as collaborators on a real project, something starts to feel missing.

The project itself doesn't really exist.

There's no shared understanding that multiple agents can build on. Long-running goals don't have an owner. Scheduled work ends up living in cron jobs and shell scripts. Before long you've accumulated a collection of markdown notes, helper scripts, and conventions that only make sense to you.

I wanted something different.

Not another coding agent. Not another model API.

A project layer that sits above the agents I already use.

What Podiom is

Podiom is a Go daemon that orchestrates the claude and codex CLIs you already have installed.

It doesn't replace Claude Code or Codex. It doesn't reimplement their tools, MCP servers, or skills. Instead, it provides the shared project state around them.

That includes:

Shared project context. Every project has a shared ledger and workspace that all configured agents can read and update, so knowledge isn't trapped inside individual conversations.
Goals. Describe an outcome, define success criteria, assign an agent, and let it plan the work, review progress, and report back over time.
Scheduling. Recurring work is just a Markdown file with YAML frontmatter. Drop it into a folder and the selected agent executes it automatically using the project's shared context.
Session continuity. Agents can continue previous work even if you switch providers or profiles, instead of starting over every time.

Podiom ships as a single static Go binary with an embedded Svelte UI and uses pure-Go SQLite (modernc.org/sqlite), so it cross-compiles cleanly across Linux, macOS, and Windows on both amd64 and arm64.

A scheduled agent is just a Markdown file

One design goal was to avoid hidden configuration.

A scheduled task is simply a Markdown file under ~/.podiom/schedules/. The YAML frontmatter defines when it runs; the body is the prompt.

---
agent: jared
model: ""
effort: low
cron: "0 7 * * *"
run_permission: preapproved
allowed_tools: []
enabled: true
goal_id: ""
---

Summarise today's calendar and add a short note to the "daily-briefs"
project. Keep it to three lines.

There's no separate scheduler configuration to maintain. Drop the file into the folder and Podiom automatically discovers it.

Because these jobs often run unattended, the default execution mode is intentionally conservative. With run_permission: preapproved, only explicitly allowed tools may perform side effects. Everything else is denied rather than silently waiting for someone to approve a prompt at 3am.

Schedules can also be managed from the CLI:

podiom schedules list
podiom schedules run morning-calendar

Every scheduled run becomes a normal Podiom session, making it easy to inspect what happened or continue the work interactively later.

Goals: what changed how I work

Scheduling answers "run this every morning."

Goals answer "keep working toward this outcome until it's actually finished."

When you create a goal, you define:

a title
a description
success criteria
optional metrics
the agent responsible for it

From there, the assigned agent creates its own plan, breaks work into tasks or schedules, periodically reviews progress, and records updates over time.

When it believes the success criteria have been met, it proposes completion.

Only you can actually mark the goal as complete.

The lifecycle is intentionally simple:

Status	Who changes it	Meaning
`active`	—	Reviews continue on schedule
`paused`	You	Reviews stop
`review`	Agent	Waiting for your decision
`done` / `abandoned`	You	Terminal state

The agent's authority ends at making a recommendation.

Under the hood

podiomd is the daemon. It hosts the web UI, scheduler, project logic, and session orchestration, backed by SQLite.

podiom is a lightweight CLI client that talks to the daemon.

The frontend is built with Svelte, Vite, TypeScript, and Tailwind, then embedded directly into the Go binary during the build.

Everything lives under a single configurable root ($PODIOM_HOME, default ~/.podiom/).

There's also a Home Assistant add-on, making it straightforward to expose Podiom outside your local network while relying on Home Assistant's authentication and security instead of exposing the daemon directly.

Current limitations

Podiom isn't another model provider.

It builds on top of the Claude Code and Codex CLIs, so you'll already need one (or both) installed and authenticated.

It's also still early (v0.4.x), intentionally single-user, and not trying to be a hosted multi-tenant platform.

Try it

curl -fsSL https://github.com/Podiom/Podiom/releases/latest/download/install.sh | bash

The installer runs podiom onboard, checks for Claude Code and Codex, and walks you through creating your first agent.

Or build it yourself (Go 1.26+, Node 20+):

make build
./bin/podiomd
./bin/podiom status

The project is MIT licensed.

Repository, documentation, and requirements:
https://github.com/Podiom/Podiom

Feedback, ideas, issues, and pull requests are all welcome.

DEV Community: Marcus Schmidt