Port42 Review – AI Companions That Build Tools on Your Mac

TL;DR

TL;DR: Port42 is a native macOS app (macOS 14+, Apple Silicon) that runs multiple AI companions in shared “channels” — they can build live interactive ports (dashboards, visualizations, terminals) inside the conversation, connect to GitHub/Stripe/Cloudflare as companions, and work alongside you and your friends in real time.

Source and Accuracy Notes

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

• Project page: port42.ai — verified
• Source repository: github.com/gordonmattey/port42-native — README read in full
• License: not clearly stated in README; binary-only distribution with source available
• HN launch thread: news.ycombinator.com/item?id=47395572
• Source last checked: 2026-06-20 (README commit verified via raw.githubusercontent.com)

What Is Port42?

Port42 is the first “companion computing” platform — not another AI chat wrapper. The README describes it as:

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

It runs on macOS 14+ (Apple Silicon only) as a native SwiftUI application. Local-first: your data stays on your machine. End-to-end encrypted, open protocol.

Key Concepts

• Companions — AI agents (Claude or Gemini, configurable per companion) that exist inside a shared channel alongside you and your friends.
• Ports — interactive surfaces (dashboards, visualizations, terminal windows) that companions build live inside the conversation using a ```port code fence.
• Channels — shared spaces where multiple humans and multiple AI companions collaborate in real time.
• Command agents — wrap any local binary or script as a companion using a simple NDJSON stdin/stdout protocol.
• Provider companions — connect GitHub, Stripe, Cloudflare, or any REST API as a companion without an SDK.

Setup Workflow

Step 1: Download and Install

Download the .dmg from the GitHub releases page:

# Latest release download (macOS 14+, Apple Silicon)
curl -L https://github.com/gordonmattey/port42-native/releases/latest/download/Port42.dmg -o /tmp/Port42.dmg

Mount the DMG and drag Port42 into your Applications folder.

Step 2: Configure Your First Companion

On first launch, Port42 prompts you to add a companion. You can choose Claude or Gemini per companion. Each companion gets its own system prompt and model preference.

Step 3: Create a Channel

Channels are shared workspaces. Create one and invite friends via a share link — anyone with the link joins with two clicks, companions included.

Step 4: Watch Companions Build Ports

Companions build interactive ports using a special code fence:

```port
<title>my 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>
```

Ports appear inline in the conversation, can be popped out into floating windows, and persist across app restarts.

Deeper Analysis

What Makes Port42 Different

Most AI tools are chat interfaces with a fixed set of capabilities. Port42’s model is different — companions are first-class participants in a shared workspace, not服务员 in a Q&A loop.

Key differentiators:

• Live ports: companions don’t just return text — they build running interfaces inside the chat
• Multi-companion synthesis: put Claude, Gemini, and a GitHub provider companion in the same channel and they work across each other’s data
• Local-first: no cloud dependency, data never leaves the machine
• Open protocol: any agent framework can plug in via the NDJSON stdin/stdout protocol

Heartbeats and Remote API

Channels can fire a “wake-up prompt” to companions on a schedule (1-minute to 60-minute intervals). Companions stay active without manual prodding.

The Remote API (/call endpoint) lets any external script or AI coding agent call the Port42 bridge API via curl — no SDK, no setup beyond enabling it in Settings.

Port Version History

Every port is versioned. Each companion update creates a snapshot. Companions can read the current HTML of an existing port before updating it, preventing blind overwrites. Available via port_get_html and port_history tools.

Terminal Game Loop

Companions running terminal sessions can drive a feedback loop: output silently routes back to the owning companion at 300ms intervals. This lets companions build reactive CLI tools, watch processes, and iterate on running code without flooding the chat.

Practical Evaluation Checklist

• [x] Native macOS app (SwiftUI, Apple Silicon)
• [x] Multiple AI companions per channel (Claude + Gemini)
• [x] Live interactive ports built by companions
• [x] Command agents for wrapping local binaries/scripts
• [x] Provider companions for GitHub, Stripe, Cloudflare, any REST API
• [x] End-to-end encrypted, open protocol
• [x] Local-first — no cloud dependency
• [x] Heartbeat scheduling (1m–60m wake-up prompts)
• [x] Remote HTTP /call API
• [x] Port version history with restore
• [x] Multiplayer via share link

Security Notes

• Local-first architecture: conversation data stays on-device. No cloud sync by default.
• Open protocol: the NDJSON command agent protocol is documented, enabling security review of what data companions can access.
• Port sandbox: ports run in a sandboxed webview with no direct network access — all data flows through the explicit port42.* bridge API.
• Remote API authentication: the /call endpoint should be secured behind appropriate network controls if exposed externally.

FAQ

Q: Is Port42 free? A: The README does not specify pricing. The binary is distributed via GitHub releases. Check port42.ai for the latest distribution model.

Q: Does it require an API key for Claude or Gemini? A: Yes — companions run on Claude or Gemini, so you will need API keys for whichever providers you use. Each companion can use a different model.

Q: Can I self-host the backend? A: Port42 is designed as a local-first app with no required backend. The Remote API allows external tools to call in, but there is no self-hosted server component — it runs entirely on your Mac.

Q: What makes “ports” different from code blocks in ChatGPT or Claude? A: Ports are live, running interfaces — not static code snippets. They persist, can be popped into floating windows, receive live data updates from companions, and have version history. A port is essentially a sandboxed webview that a companion builds and updates dynamically during conversation.

Q: Is the source code open source? A: The repository is public on GitHub. The port42-native repo contains the source. The port42-openclaw repo appears to be the open protocol implementation.

Conclusion

Port42 is a genuinely novel take on human-AI collaboration. Instead of switching between a chat window and your terminal, companions bring their tools directly into the conversation — building dashboards, running code, calling APIs — while you and your teammates work alongside them in real time.

The local-first, open-protocol design means you’re not locked into another cloud service. If you want AI agents that do more than generate text, Port42 is worth a closer look.

Download the .dmg from the GitHub releases page and try it on macOS 14+ (Apple Silicon).