Model or dataset
pulseaiclub/phi avatar
pulseaiclub/phi

phi: the footprint table says six direct dependencies, go.mod requires seven, two YAML v3 packages ship, and the optimizer's default is never stated

a coding agent, rpc plugin, sub-agents, hashline edits, and mcp

1,005 stars60 forksGoMIT

At a glance

What is it?
phi is a Go coding agent with a terminal UI, sub-agents, a permission gate, progressive MCP loading, hashline edits, and plugins for OpenAI, Anthropic, and Gemini. It is unusually transparent about its size, publishing a footprint table with binary weight, memory, and build times, and it tells you exactly how to reproduce those numbers. It is much less precise about what it depends on and what it sends.
Who is it for?
phi is a credible choice for a terminal coding agent if you like a single static binary and a permission gate, and its build defaults match its published numbers exactly, which is rarer than it sounds. Three things to settle first.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly Go, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • pulseaiclub/phi1,005 ★ · +608
Star history
Repository2026-09-152026-11-15
pulseaiclub/phi3971k

608 Stars in the last 61 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The dependency count in the metrics table does not match go.mod

The footprint table ends with a row reading Direct module deps, six, with fifteen modules total. `go.mod` disagrees on both numbers. The direct require block lists seven entries: a syntax highlighter, the project's own extension module, two more of its own modules, a test assertion library, a Markdown renderer, and a YAML library. The second block adds two indirect entries. That is seven direct and nine modules in the file, not six and fifteen. The gap matters less for the total than for the direct figure, because that is the number a reader uses to judge how much third-party code they are taking on. Of the seven in the file, three are the author's own repositories, so the count of genuinely external direct dependencies is four. One of those four is a test-only library that never reaches the shipped binary.

Two YAML v3 packages and a version that a replace directive discards

The module file requires `gopkg.in/yaml.v3` directly and pulls in `go.yaml.in/yaml/v3` indirectly, so two separate implementations of the same major version of the same library sit in the graph at different patch levels. That happens when a dependency moves between the two canonical import paths and both remain reachable, and it is harmless as long as only one is imported. The file also requires the project's own extension module at `v0.25.2`, three minor versions behind the repository's newest tag of `v0.28.1`, and then immediately discards that version with a replace directive pointing at a local directory. So the required version is mandatory to write and never consulted, and no reader of `go.mod` alone can tell which extension module is actually compiled in. The `ext/go` directory is present, so the code is there; it just is not versioned in the place a reader would look.

Two lists of the same home directory and hooks appears in only one

The quick start says that on first start phi creates four directories under the user's home: `bin`, `skills`, `hooks`, and `session`. The workspace layout section draws the same tree and lists six entries plus the config file: `config.yaml`, `bin/`, `skills/`, `extensions/`, `jobs/`, and `session/`. So `hooks/` exists in one list and not the other, while `extensions/` and `jobs/` exist in the diagram and not in the prose. The diagram annotates them helpfully, `bin/` holding downloaded search tools, `extensions/` holding extension binaries and their manifest, `jobs/` holding sub-agent job artifacts with metadata, logs, and a result file, and `session/` holding one directory per working directory. Two of the three missing-from-the-prose directories are where sub-agent output and third-party extension binaries land, which are the parts a user is most likely to want to know are on disk.

The optimizer uploads shell history and its default is never stated

The environment override table lists a master switch for optimizer features and accepts four values that disable it. A separate row lists a TypeSafe API key required for those features. The security note beneath is unambiguous: when the optimizer is enabled, command history and context are sent to an external TypeSafe service for judging and ranking, and you should avoid it in environments where shell history may contain sensitive information, with API keys, tokens, and credentials given as examples. That warning is well placed. What is missing is the default. Four disable spellings are enumerated and no sentence says whether a fresh installation has the optimizer on or off, which means the one setting that determines whether your shell history leaves the machine cannot be determined from the page. Note also what the same paragraph concedes about the rest of the agent: the tools it hands the model are `read`, `write`, `edit`, and `bash`, plus `grep`, `find`, and `ls`.

make install moves the binary and leaves nothing behind to run

The build recipe compiles with `CGO_ENABLED=0` and strip flags, which are exactly the settings the footprint page says its numbers come from, so the measurements are reproducible from the Makefile defaults:

sh
make build          # produces ./phi
make install        # build and install into $GOBIN

The install recipe is the problem. It runs `mkdir -p` on the Go bin directory and then `mv` the compiled binary into it. A move, not a copy. So `make build` produces a local `./phi`, `make install` relocates it, and the documented three-step sequence in the page, `make build` then `make install`, leaves you with no binary in the working directory. The `run` target depends on `build` and then invokes `./$(BINARY)`, so running it after an install triggers a rebuild first. None of this is dangerous, but it means the two documented commands are not independent, and the failure a newcomer hits is a missing file rather than an error message.

The one pinned thing in the Makefile is a Docker image, and check is cut off

The Makefile pins exactly one external artefact, and it pins it properly: a Markdown lint image referenced by digest, with a comment explaining that CI and local runs should use the same image. Nothing else is pinned. `golangci-lint` is expected on the path at whatever version, `go` is whatever the module directive resolves, and `cargo` is invoked for the Rust extension target without a toolchain file in evidence. There is also a `deadcode` target running a script, and a `generate-check` target that fails when generated wire code is stale, both described as used by CI. Then there is the aggregated target, whose `.PHONY` declaration promises `check` and whose recipe begins `check: fmt-che` and stops there. A reader cannot see what the one command they are meant to run before a pull request actually does, which is the same gap as a missing closing bracket: the page looks complete until you try to use it.

A Rust extension SDK beside a table promising no other runtimes

The footprint table's last row reads Linked runtimes, system libs only, with no Node, no Electron, and no Python. The Makefile has a `test-rust` target that changes into `ext/rust` and runs `cargo test --all-targets`, and a comment above it calls that the Rust extension SDK. So the project that advertises a single static binary with no foreign runtime ships a Rust toolchain path for its extension SDK. That is not a contradiction in the shipping artefact, since the Rust half compiles into native extension binaries rather than needing a runtime present, but it is a gap in the framing. The same gap appears in the search tools. On first start, if `fd` and `rg` are missing, phi downloads them into its own `bin/` directory in the background. A tool whose headline is a fifteen megabyte binary quietly fetches two more executables on first run, with no version, checksum, or signature mentioned for either.

Editorial conclusion

phi is a credible choice for a terminal coding agent if you like a single static binary and a permission gate, and its build defaults match its published numbers exactly, which is rarer than it sounds. Three things to settle first. Find out whether the optimizer is on before you use it, because the page enumerates four ways to switch it off and never says which state a fresh install is in, and what it uploads is your shell history. Count your dependencies from go.mod rather than from the footprint table, since the table and the module file disagree. And expect three of the direct dependencies to be the author's own modules, one of them resolved from a local directory by a replace directive, so the third-party surface is four modules rather than six or seven.

Frequently asked questions

How many dependencies does phi have?

The footprint table claims six direct dependencies and fifteen modules total. `go.mod` requires seven modules directly and lists two more as indirect, and three of the direct entries are the author's own repositories, one of them resolved from a local directory by a replace directive.

What does PHI_OPTIMIZER send to an external service?

When enabled, command history and context are sent to an external TypeSafe service for judging and ranking, and a `TYPESAFE_API_KEY` is required. The page warns against using it where shell history may contain API keys, tokens, or credentials, and does not state whether a fresh install has it enabled.

What tools does phi give the model?

Four core tools, `read`, `write`, `edit`, and `bash`, plus `grep`, `find`, and `ls`. External HTTP fetching is available through MCP when a server is configured. A permission gate and native diff review sit in front of the write and execute tools.

How do I build phi from source?

With Go 1.26.3 or newer, run `make build` for a local binary or `make install` to place it in your Go bin directory. The install target moves the compiled file rather than copying it, so the local binary is gone afterwards.

Official sources

  1. License: MIT
  2. Project website
  3. pulseaiclub/phi on GitHub
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/pulseaiclub-phi.svg)](https://hysenlabs.com/projects/pulseaiclub-phi)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/pulseaiclub-phi.svg)](https://hysenlabs.com/projects/pulseaiclub-phi)

Was this useful?