Port42 Review: macOS AI Agents That Build Together

TL;DR

TL;DR: Port42 is a native macOS app (MIT, open source) where multiple AI companions coexist with humans in shared chat channels, building real-time interactive visualizations, dashboards, and terminal sessions together — not just chatting.

Source and Accuracy Notes

⚠️ This section is MANDATORY. All links must be verified from actual source, not guessed.

• Project page: port42.ai — verified via curl, OG meta tags confirmed
• Source repository: github.com/gordonmattey/port42-native — README read end-to-end, 615 lines
• License: MIT (verified via license.spdx_id from GitHub API)
• HN launch thread: news.ycombinator.com/item?id=45262658
• Stars: 5 (as of 2026-07-22, GitHub API)
• Source last checked: 2026-07-22 (commit main, pushed 2026-07-21)

What Is Port42?

Port42 describes itself as “companion computing” — a native macOS app (macOS 14+, Apple Silicon) where you, your friends, and multiple AI companions share the same conversation space. The tagline: “Humans and AI, thinking together.”

The core insight from the HN launch: the founder was drowning in tabs and context switches and built Port42 as an alternative to chat-wrapping AI tools. Rather than copy-pasting between apps, Port42 brings everything into one shared surface.

From the README:

A native Mac app where you, your friends, and your AI companions share the same space. Talk, build, and watch ideas take shape together.

Key features (verbatim from README):

• Companions — Multiple AI companions per channel, per-companion model selection (Claude or Gemini). They can see each other’s work and build collaboratively.
• Command agents — Wrap any local binary or script as a companion speaking a simple NDJSON protocol on stdin/stdout.
• Terminal companions — Run Claude Code or Gemini CLI as inline, live terminal ports inside a chat channel.
• Provider companions — Connect GitHub, Stripe, Cloudflare, or any REST API as companions with just a system prompt and rest.call.
• Ports — Interactive surfaces (visualizations, dashboards, 3D scenes, games) that companions build on the fly inside conversations using a ```port code fence. Ports run as sandboxed webviews with a port42.* JavaScript bridge.
• Relationship memory — Companions retain context (fold, position, creases) across sessions.
• Heartbeats — Scheduled wake-up prompts (1m to 60m intervals) keep companions active without manual prompts.
• Remote API — HTTP /call endpoint exposes the full bridge API to external tools and scripts.
• Multiplayer — Share a link and anyone joins with two clicks, bringing their companions.
• Open Protocol — E2E encrypted, open source, local-first. No cloud dependency.
• Swims — Deep 1:1 sessions with any companion, continuous context that never resets.

Setup Workflow

Prerequisites

• macOS 14+ (Sonoma or later)
• Apple Silicon (M1 or later)
• Homebrew (recommended for build dependencies)

Option 1: Download Pre-built DMG

The README provides a direct download link:

# Download from the releases page
open https://github.com/gordonmattey/port42-native/releases
# Or use the DMG link from README
curl -L -o ~/Downloads/Port42.dmg "https://github.com/gordonmattey/port42-native/releases/latest/download/Port42.dmg"

Option 2: Build from Source

Requires macOS 14+, Swift 6, and Go 1.21+:

# Clone the repo
git clone https://github.com/gordonmattey/port42-native
cd port42-native

# Debug build and launch
./build.sh --run

# Release build (signs, notarizes, produces DMG)
./build.sh --release

Note: The build.sh script automatically creates a .build symlink pointing to ~/port42-build to avoid cloud-sync corruption issues with Dropbox and similar tools.

Configure AI Providers

After first launch, go to Settings → AI Providers to add your API keys for Claude or Gemini. Each companion can select its own model independently.

Connect Claude Code or Gemini CLI

From Settings → Remote Access, choose:

• Install for Claude Code — writes the full API reference to ~/.claude/CLAUDE.md
• Install for Gemini CLI — writes the API reference to ~/.gemini/GEMINI.md

After installing, start a new terminal session for the changes to take effect. The CLI can then call any Port42 bridge API via curl.

Deeper Analysis

Ports: The Killer Feature

Ports set Port42 apart from every other AI chat tool. A companion creates a port with a ```port code fence:

```port
<title>companion dashboard</title>
<meta name="version" content="1">
<div id="app"></div>
<script>
  const companions = await port42.companions.list()
  document.getElementById('app').innerHTML =
    companions.map(c => `<div>${c.name} (${c.model})</div>`).join('')
</script>
```

Port42 wraps this in a themed document and renders it as a live, interactive surface inside the chat. Multiple companions can push updates to the same port (version-tracked). Ports can be popped out onto the desktop as tiles and persist across app restarts.

Bridge API

Ports get a port42.* JavaScript bridge with methods for:

• port42.companions.list() / .invoke() — query and call companions
• port42.ai.models() / .complete() — raw LLM access
• port42.messages.recent() / .send() — channel message history
• port42.space — current space metadata
• port42.terminal.* — terminal execution
• port42.clipboard.*, port42.screen_capture, port42.fs.* — device APIs

A WebSocket API at ws://127.0.0.1:4242/ws also exposes the full bridge for external clients and CLI tools.

Architecture

Port42.app
  ├── Port42 (Swift/SwiftUI native app)
  │   ├── Port42Lib (shared library)
  │   ├── Port42 (main app with Sparkle updates)
  │   └── Port42B (peer app for testing)
  ├── port42-gateway (Go WebSocket server, bundled)
  └── ngrok (optional, for internet sharing)

State flows: SQLite (GRDB) → AppState (ObservableObject) → SwiftUI Views. GRDB ValueObservation keeps UI in sync reactively.

Practical Evaluation Checklist

• macOS 14+ required — not available on Intel or older macOS
• Apple Silicon only — M1/M2/M3/M4 series
• Local-first — all data stays on your machine, no mandatory cloud
• Open source — MIT license, github.com/gordonmattey/port42-native
• Multi-agent per channel — multiple companions can see each other’s work
• Real-time Ports — interactive surfaces built on the fly by AI
• Terminal integration — Claude Code and Gemini CLI run inline
• REST API integration — GitHub, Stripe, Cloudflare as companions via rest.call
• WebSocket API — ws://127.0.0.1:4242/ws for external tools

Security Notes

• E2E encrypted — stated in README, open protocol
• Local-first — no mandatory cloud sync, data stays on-device
• Sandboxed webviews — Ports have no network access, all data flows through the port42.* bridge
• Command agents — local binaries/scripts wrapped as companions run with user permissions; review the NDJSON protocol before trusting unknown scripts
• Remote API — the HTTP /call endpoint exposes bridge APIs; keep it disabled or firewalled when not in use

FAQ

Q: Is Port42 available on Linux or Windows? A: No. Port42 is a native macOS (Apple Silicon) application only. There is no Linux or Windows build.

Q: Does it work with models other than Claude and Gemini? A: Per the README, companions can run on Claude or Gemini set per-companion. The raw port42.ai.complete() API is model-agnostic and may support other providers via configuration.

Q: How does it differ from Claude Code or Gemini CLI running in a terminal? A: Port42’s terminal companions run inside the chat UI as live ports — you see the full CLI interaction inline alongside human and AI messages. Claude Code and Gemini CLI both have deep Port42 integration via auto-installed API references in ~/.claude/CLAUDE.md and ~/.gemini/GEMINI.md.

Q: Can multiple humans collaborate in the same channel? A: Yes. Sharing a link lets anyone join a channel with two clicks, and they bring their own companions. The gateway runs locally; ngrok tunneling enables internet sharing.

Q: What is the “Swims” feature? A: Deep 1:1 sessions with any companion that maintain continuous context without resets — described as a dedicated feature in the README.

Conclusion

Port42 takes a genuinely different approach to AI tooling: instead of one AI per task, it creates shared spaces where multiple humans and multiple AI companions build together in real time. The Ports system — where companions spin up interactive surfaces on demand inside a conversation — is the standout idea. If you are on macOS 14+ with Apple Silicon, it is worth a try. The MIT-licensed native app is free to download, and the source is on GitHub.

For runany.dev readers focused on AI setup and developer tools, Port42 sits at an interesting intersection: it is both an AI tool you use and a platform for building AI-powered workflows with Claude Code, Gemini CLI, and custom command agents all visible in the same conversation.