Claude’s Corner: Byteport, The Pipe the AI Era Forgot to Build

# How to Build a Byteport Clone with Claude Code

A step-by-step guide to building a high-speed UDP-based file transfer protocol and SaaS platform targeting AI, robotics, and satellite workloads.

---

## Step 1: Design the Protocol (DART Architecture)

Build a custom transport protocol on top of UDP that provides reliability, ordering, flow control, and congestion control optimized for bulk large-file transfers.

**Core protocol concepts to implement:**

```
Packet structure:
| magic (4B) | seq_num (8B) | ack_num (8B) | flags (2B) | checksum (4B) | payload |

Flags:
- SYN / FIN / ACK / NACK / DATA / CTRL

State machine:
  CLOSED → HANDSHAKE → ESTABLISHED → TRANSFER → FIN_WAIT → CLOSED
```

**Congestion control, implement BBR (Bottleneck Bandwidth and RTT):**
- Probe bandwidth in cycles: STARTUP → DRAIN → PROBE_BW → PROBE_RTT
- Track min-RTT over 10-second windows
- Track max-bandwidth over 10 packet-round windows
- Set pacing rate to 1.25× estimated bandwidth during PROBE_BW
- Distinguish packet loss from congestion (BBR) vs. corruption, do NOT back off on corruption-only loss

**Reliability without TCP head-of-line blocking:**
- Selective acknowledgements (SACK), receiver reports which packets it has
- Sender retransmits only missing ranges, not everything after the gap
- FEC (Forward Error Correction) as optional layer: Reed-Solomon over blocks of 64 packets

**Key DB schema for transfer state:**
```sql
CREATE TABLE transfers (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  tenant_id UUID NOT NULL,
  source_endpoint TEXT NOT NULL,
  destination_endpoint TEXT NOT NULL,
  file_size_bytes BIGINT NOT NULL,
  bytes_transferred BIGINT DEFAULT 0,
  status TEXT DEFAULT 'pending', -- pending, active, paused, complete, failed
  checksum_sha256 TEXT,
  created_at TIMESTAMPTZ DEFAULT now(),
  completed_at TIMESTAMPTZ,
  protocol_version TEXT DEFAULT 'DART/1.0'
);

CREATE TABLE transfer_segments (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  transfer_id UUID REFERENCES transfers(id),
  segment_index INT NOT NULL,
  byte_offset BIGINT NOT NULL,
  byte_length INT NOT NULL,
  status TEXT DEFAULT 'pending', -- pending, sent, acked, lost
  retransmit_count INT DEFAULT 0
);
```

---

## Step 2: Implement the Agent Binary (Go or Rust)

The agent is the daemon that runs on source and destination machines, exposes a local gRPC/HTTP API, and handles the actual DART protocol over UDP sockets.

**Language recommendation: Rust or Go**
- Rust: zero-copy buffers, fine-grained memory control, excellent for high-throughput networking
- Go: faster to ship, strong networking stdlib, goroutines map well to connection handling

**Core agent components:**

```go
// agent/main.go

type DARTAgent struct {
    udpConn     *net.UDPConn
    sessions    map[SessionID]*TransferSession
    congestion  *BBRController
    encryptor   *AES256GCMEncryptor
    apiServer   *grpc.Server
}

// Each session tracks its own congestion window, RTT estimates, SACK state
type TransferSession struct {
    id            SessionID
    peerAddr      *net.UDPAddr
    sendWindow    *SlidingWindow
    recvBuffer    *ReorderBuffer   // handles out-of-order UDP delivery
    rttEstimator  *RTTEstimator    // Jacobson/Karels algorithm
    cwnd          float64          // congestion window (packets)
    pacingRate    float64          // bytes/sec
    fileHandle    *os.File
    segmentMap    []SegmentState
}
```

**Key algorithms to get right:**
1. **Receive reorder buffer**, UDP packets arrive out of order; buffer them and deliver in-order to the application
2. **Send pacing**, don't burst; space packets according to `pacingRate` to avoid buffer bloat
3. **Fast retransmit**, on 3 duplicate ACKs, retransmit without waiting for timeout
4. **Selective repeat ARQ**, NACK-based retransmission of specific segments

**AES-256-GCM encryption per session:**
```
Session key = ECDH(sender_ephemeral, receiver_ephemeral)
Each packet: encrypt(payload, nonce=seq_num, aad=session_id)
```

---

## Step 3: Build the Control Plane API

REST + WebSocket API (use Fastify/Node.js or Go's net/http) that the agent reports to and that the dashboard calls.

```
POST   /api/transfers              -- initiate transfer
GET    /api/transfers/:id          -- status + progress
PUT    /api/transfers/:id/pause    -- pause mid-transfer
DELETE /api/transfers/:id          -- cancel
GET    /api/transfers/:id/metrics  -- throughput, RTT, loss rate
WS     /api/transfers/:id/stream   -- real-time progress events
```

**Multi-tenancy schema:**
```sql
CREATE TABLE tenants (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  name TEXT NOT NULL,
  plan TEXT DEFAULT 'growth',         -- growth | enterprise
  throughput_limit_mbps INT,          -- NULL = unlimited
  api_key TEXT UNIQUE NOT NULL,
  created_at TIMESTAMPTZ DEFAULT now()
);

CREATE TABLE endpoints (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  tenant_id UUID REFERENCES tenants(id),
  agent_version TEXT,
  public_key TEXT NOT NULL,           -- for mutual auth
  last_seen TIMESTAMPTZ,
  hostname TEXT,
  ip_address INET
);
```

**Rate limiting by plan:**
```js
// middleware/rateLimit.js
async function enforceThroughput(tenant, currentMbps) {
  if (tenant.plan === 'growth' && currentMbps > 1000) {
    throw new ThroughputLimitError('Upgrade to Enterprise for unlimited throughput');
  }
}
```

---

## Step 4: Build the Stream SDK

The Stream SDK lets applications feed live byte streams into DART without writing a complete file first, critical for robotics telemetry and video capture.

```python
# byteport_sdk/stream.py

class ByteportStream:
    def __init__(self, api_key: str, destination: str):
        self.agent = DARTAgentClient(api_key)
        self.session = self.agent.open_stream(destination)
    
    def write(self, data: bytes) -> None:
        """Non-blocking; buffers internally and paces via DART congestion control."""
        self.session.write(data)
    
    def flush(self) -> None:
        self.session.flush()
    
    def close(self) -> TransferReceipt:
        return self.session.close()

# Usage in robotics:
# stream = ByteportStream(api_key, "robot-lab-server:4040")
# for frame in camera.capture():
#     stream.write(frame.serialize())
# stream.close()
```

**Ship SDKs in this order:** Python → Go → Node.js → C++ (robotics/embedded)

Each SDK wraps the gRPC API exposed by the local agent, the SDK itself doesn't implement the protocol, it talks to the locally-running agent binary.

---

## Step 5: Measurement, Monitoring, and Benchmarking Infrastructure

Your protocol is only credible if you have reproducible benchmarks. Build this from day one.

**Core metrics to instrument:**
```
- Goodput (actual data bytes / second, excluding protocol overhead)
- RTT (sampled every 10ms)
- Packet loss rate (per session)
- Retransmit rate
- Bandwidth utilization (goodput / link capacity)
- Transfer completion time vs. TCP baseline
```

**Benchmark harness:**
```bash
# Run this on a controlled pair of EC2 instances with tc netem for loss simulation
tc qdisc add dev eth0 root netem loss 2% delay 100ms

# Then compare:
dart-bench --src local --dst remote --file 10GB.bin --protocol dart
dart-bench --src local --dst remote --file 10GB.bin --protocol tcp
# Publish these numbers publicly, it's your marketing
```

**Monitoring stack:**
- Agent emits metrics via Prometheus endpoint
- Grafana dashboards per tenant
- Alert on: goodput drops >20%, session RTT spike >3x baseline, retransmit rate >5%

```sql
CREATE TABLE transfer_metrics (
  transfer_id UUID REFERENCES transfers(id),
  recorded_at TIMESTAMPTZ DEFAULT now(),
  goodput_mbps FLOAT,
  rtt_ms FLOAT,
  packet_loss_pct FLOAT,
  retransmit_rate FLOAT,
  bandwidth_util_pct FLOAT
);
CREATE INDEX ON transfer_metrics (transfer_id, recorded_at DESC);
```

---

## Step 6: Enterprise Deployment Modes

Enterprise customers need on-premises, air-gapped, and hybrid deployments. Design for this from the start, retrofitting is painful.

**Docker-first packaging:**
```dockerfile
FROM ubuntu:24.04
COPY dart-agent /usr/local/bin/dart-agent
COPY control-plane /usr/local/bin/byteport-control
EXPOSE 4040/udp    # DART protocol
EXPOSE 8443/tcp    # HTTPS API
EXPOSE 9090/tcp    # Prometheus metrics
ENTRYPOINT ["dart-agent", "--config", "/etc/byteport/config.yaml"]
```

**Air-gapped mode** (no outbound internet, no cloud control plane):
```yaml
# config.yaml for air-gapped deployment
mode: air_gapped
control_plane: local              # runs embedded control plane
license: /etc/byteport/license.key
telemetry: disabled
update_check: disabled
```

**Key compliance requirements to design around:**
- FIPS 140-2: use only FIPS-approved cipher suites (AES-256-GCM, SHA-384, ECDH P-384)
- FedRAMP: audit logs for every transfer with user, timestamp, file hash, source/dest IPs
- ITAR: geofencing, refuse transfers to embargoed countries at the protocol level

```sql
-- Immutable audit log (append-only)
CREATE TABLE audit_log (
  id BIGSERIAL PRIMARY KEY,
  tenant_id UUID NOT NULL,
  event_type TEXT NOT NULL,
  transfer_id UUID,
  user_id UUID,
  source_ip INET,
  dest_ip INET,
  file_sha256 TEXT,
  occurred_at TIMESTAMPTZ DEFAULT now()
) WITH (fillfactor=100);

-- Prevent deletes via RLS policy
ALTER TABLE audit_log ENABLE ROW LEVEL SECURITY;
CREATE POLICY no_delete ON audit_log FOR DELETE USING (false);
```

---

## Step 7: Go-to-Market and Pricing Infrastructure

Build the Stripe integration and usage metering from day one, it changes your architecture.

**Usage metering:**
```sql
CREATE TABLE usage_events (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  tenant_id UUID REFERENCES tenants(id),
  transfer_id UUID,
  bytes_transferred BIGINT NOT NULL,
  recorded_at TIMESTAMPTZ DEFAULT now()
);

-- Aggregate for billing (run hourly via pg_cron)
CREATE MATERIALIZED VIEW monthly_usage AS
SELECT tenant_id,
       date_trunc('month', recorded_at) AS month,
       SUM(bytes_transferred) AS total_bytes
FROM usage_events
GROUP BY 1, 2;
```

**Stripe metered billing:**
```js
// When a transfer completes, report usage
await stripe.subscriptionItems.createUsageRecord(
  subscriptionItemId,
  { quantity: Math.ceil(transfer.bytesTransferred / 1e9), action: 'increment' } // per-GB
);
```

**Self-serve onboarding flow:**
1. Sign up → create tenant → generate API key
2. Download agent binary for OS (Linux/macOS/Windows ARM/x86)
3. `dart-agent --api-key YOUR_KEY --register` (agent phones home, registers endpoint)
4. First transfer: `dart-transfer --from /data/model.bin --to endpoint-id://remote/dest/`

**Target first 10 customers:** robotics teams at university labs (free tier), then Series A robotics companies with real data pipeline pain. Defense is a 24-month sales cycle minimum, don't bank on it in year one.

---

## Stack Summary

| Layer | Technology |
|-------|-----------|
| Protocol | Custom UDP/DART in Rust or Go |
| Agent API | gRPC (internal), REST+WebSocket (external) |
| Control Plane | Go or Node.js, PostgreSQL |
| SDKs | Python, Go, Node.js, C++ |
| Infrastructure | AWS/GCP for SaaS; Docker for on-prem |
| Auth | API keys + mTLS between agents |
| Encryption | AES-256-GCM with ECDH key exchange |
| Monitoring | Prometheus + Grafana |
| Billing | Stripe metered billing per GB |
| CI | GitHub Actions, automated benchmark regression tests |