Port42 - Native Mac App for Human-AI Companion Computing

TL;DR

TL;DR: Port42 is a native macOS app (Apple Silicon, macOS 14+) that embeds multiple AI companions directly into shared conversations alongside humans — they riff off each other, build interactive ports in real time, and run end-to-end encrypted on your machine.

Source and Accuracy Notes

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

• Project page: port42.ai
• Source repository: github.com/gordonmattey/port42-native — MIT license, 5 stars, last push 2026-06-28
• HN launch thread: news.ycombinator.com/item?id=47395572 (v0.5.0)
• Source last checked: 2026-07-09

What Is Port42?

Port42 is the first “companion computing” platform. Rather than yet another AI chat wrapper, it creates a shared space where multiple humans and multiple AI companions exist in the same conversation, building things together in real time. The project describes itself as “Humans and AI, thinking together.”

The app is a native SwiftUI binary for Apple Silicon on macOS 14 and later — no Electron, no cloud dependency. All data stays local.

Core Concepts

• Companions — AI agents that live inside a conversation. Each companion runs on Claude or Gemini (configurable per companion). Multiple companions in the same channel riff off each other and build on ideas collectively.
• Command agents — Wrap any local binary or script as a companion. The process speaks NDJSON on stdin/stdout and Port42 routes messages to it like any other companion.
• Terminal companions — Run Claude Code or Gemini CLI directly as a native companion. Channel messages route into the CLI; its responses post back inline. Pop the terminal out to a floating window when you need more space.
• Provider companions — Connect GitHub, Stripe, Cloudflare, or any REST API as a companion. The companion IS the integration: no SDK, just a system prompt and rest.call.
• Ports — Interactive surfaces that companions build live inside conversations. Visualizations, dashboards, games, tools. They run as sandboxed webviews with access to channel data through the port42.* bridge API. Ports can be popped out to floating windows and persist across app restarts.
• Relationship memory — Companions carry persistent context (fold, position, creases) across every session without being reminded.
• Heartbeats — Channels can fire a wake-up prompt on a schedule (1 minute to 60 minutes). Set it once and companions stay active after a restart.
• Remote API — An HTTP /call endpoint lets any external tool or AI coding agent call the bridge API via curl.

Setup Workflow

Prerequisites

• macOS 14 or later
• Apple Silicon (M1/M2/M3/M4)
• Download the latest .dmg from GitHub releases

Step 1: Download and Install

# Download the latest release directly
curl -L https://github.com/gordonmattey/port42-native/releases/latest/download/Port42.dmg -o /tmp/Port42.dmg

# Open the DMG and drag Port42 to Applications
open /tmp/Port42.dmg

Step 2: Configure Your First Companion

1. Launch Port42 from Applications
2. Click + Add Companion in the sidebar
3. Choose a provider: Claude or Gemini (per companion)
4. Enter your API key when prompted
5. The companion appears in your channel alongside you

Step 3: Add a Terminal Companion (Optional)

For Claude Code or Gemini CLI as a native companion:

1. Install the CLI tool separately (npm install -g @anthropic-ai/claude-code or npm install -g @google/generativeai)
2. In Port42, add a new companion and select Terminal type
3. Point it to the CLI binary path
4. The companion opens as an inline terminal port — messages in the channel route directly into the CLI

Step 4: Connect a Provider Companion (Optional)

Provider companions wrap external services as AI-accessible tools:

// Example: a GitHub provider companion
// The companion IS the integration — no SDK
const issues = await rest.call({
  method: 'GET',
  url: 'https://api.github.com/repos/gordonmattey/port42-native/issues',
  headers: { Authorization: 'token YOUR_GITHUB_TOKEN' }
})

Deeper Analysis

What Makes Port42 Different

Most AI tools slot a model into a fixed interface. Port42 inverts this: the companions shape the interface themselves, in real time, using ports — interactive surfaces rendered inside conversations.

A companion emits a port with a special 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('')
  port42.on('message', e => console.log('new:', e.sender))
</script>
```

Port42 wraps this in a themed document automatically. The port42.* bridge is the only limit — and it is fully open.

Open Protocol and Local-First Design

Port42 is open source (MIT) and end-to-end encrypted. No cloud dependency — your data stays on your machine. Any agent framework can plug into the protocol with a few lines of code.

Command Agents: Extending Beyond LLMs

The NDJSON command agent protocol lets you wrap any CLI tool as a companion:

1. Your script reads JSON messages from stdin
2. Port42 sends channel messages routed as structured JSON
3. Your script writes NDJSON responses back to stdout
4. Port42 posts those responses to the channel

This means local build tools, scripts, database CLIs — anything with a command-line interface — can participate in a conversation alongside LLMs.

Practical Evaluation Checklist

• macOS 14+ Apple Silicon required — no Intel, no Linux/Windows
• API keys needed for Claude/Gemini — companions are not free-to-run; you pay for the underlying model
• Local-first — all data on-device, no cloud lock-in
• Open protocol — MIT licensed, extensible by any agent framework
• Multi-agent in one channel — unlike single-LLM chat wrappers, Port42 runs multiple companions simultaneously
• Ports system — unique interactive surface builder inside conversations

Security Notes

• End-to-end encrypted by design
• Local data storage — nothing sent to a cloud unless you explicitly configure a remote API
• Remote API (/call endpoint) must be explicitly enabled in Settings — not on by default
• No telemetry or phone-home confirmed in the MIT source

FAQ

Q: Is Port42 free to use? A: The app is free and open source (MIT). However, each AI companion routes through Claude or Gemini, so you need API keys for the underlying models. Costs depend on your usage.

Q: Does it work on Intel Macs? A: No — Port42 requires Apple Silicon (macOS 14+).

Q: Can I run this on Linux or Windows? A: No. Port42 is a native SwiftUI macOS app and has no cross-platform builds.

Q: How is this different from ChatGPT’s macOS app or Claude.app? A: Port42 runs multiple AI companions simultaneously in the same conversation, not a single model. Companions can be humans, LLMs, terminal sessions, or REST API wrappers. The port system also lets companions build interactive UIs live inside conversations.

Q: What is the NDJSON command agent protocol? A: It is a simple stdin/stdout protocol where Port42 sends JSON messages to a local process and reads NDJSON responses back. Any CLI tool can be wrapped as a companion this way — no special SDK required.

Conclusion

Port42 is a genuinely different take on the AI tool category — a native macOS companion platform rather than another chat wrapper. The combination of multi-agent channels, a live port system for interactive surfaces, and the open NDJSON command agent protocol makes it worth trying if you want AI tooling that goes beyond single-LLM chat on Apple Silicon.

Download the .dmg from the GitHub releases page or read more at port42.ai.