CapTP: Capability Transfer Protocol

Trit: 0 (ERGODIC - transports capabilities without amplification) Color: #46F27F (Coordinator stream) Source: Spritely Goblins (codeberg.org/spritely/goblins)

Overview

CapTP (Capability Transfer Protocol) enables distributed object programming with capability security. Objects can live anywhere on the network; CapTP abstracts location so programmers focus on object interaction, not protocol architecture.

Core principle: Capabilities are unforgeable references. You can only invoke what you've been given.

Key Concepts

Vats (Actor Containers)

;; Guile Goblins
(define vat (spawn-vat))
(define greeter (vat-spawn vat ^greeter))

Promise Pipelining

;; Don't wait for result - pipeline through promises
(<- (<- alice 'get-friend) 'greet "Hello")

Reduces round-trips: send message to promise, network resolves.

Sturdy vs Live References

CapTP Message Types

op:deliver-only  → Fire-and-forget message
op:deliver       → Message expecting response
op:pick          → Select from multiple promises
op:abort         → Cancel pending operation
op:listen        → Subscribe to updates
op:gc            → Garbage collection hint

GF(3) Triads

# Core CapTP Bundle
keychain-secure (-1) ⊗ captp (0) ⊗ gay-mcp (+1) = 0 ✓  [Secure Transport]
shadow-goblin (-1) ⊗ captp (0) ⊗ agent-o-rama (+1) = 0 ✓  [Distributed Actors]
polyglot-spi (-1) ⊗ captp (0) ⊗ pulse-mcp-stream (+1) = 0 ✓  [Cross-Lang Objects]
temporal-coalgebra (-1) ⊗ captp (0) ⊗ koopman-generator (+1) = 0 ✓  [State Observation]

# Goblins Integration
three-match (-1) ⊗ captp (0) ⊗ gay-mcp (+1) = 0 ✓  [Colored Capabilities]
sheaf-cohomology (-1) ⊗ captp (0) ⊗ operad-compose (+1) = 0 ✓  [Compositional]

Implementation Bridge

Mapping to Our Goblins

Ruby Integration

require 'captp'

# Create vat (generator with transactional boundary)
vat = CapTP::Vat.new(seed: 0x42D)

# Spawn actor (color stream)
actor = vat.spawn(:color_stream)

# Send message (advance stream)
promise = actor.send(:next_color)

# Pipeline (derive without waiting)
result = actor.send(:palette, 5).then { |colors| colors.map(&:hex) }

Scheme Integration (Hoot target)

(use-modules (goblins) (goblins actor-lib cell))

;; Define actor constructor
(define (^color-stream bcom seed)
  (define idx (spawn ^cell 0))
  (lambda (method . args)
    (case method
      ((next-color)
       (let ((i ($ idx)))
         ($ idx (+ i 1))
         (color-at seed i)))
      ((palette)
       (map (lambda (i) (color-at seed i))
            (iota (car args)))))))

;; Spawn in vat
(define stream (spawn ^color-stream 1069))
(<- stream 'next-color)  ;; => promise of color

Netlayers

Security Model

Principle of Least Authority (POLA)

You can only:
1. Use capabilities you were given
2. Create new objects (that you then have caps to)
3. Introduce objects you have caps to, to each other

Attenuation

# Full capability
full_stream = vat.spawn(:color_stream, seed: 0x42D)

# Attenuated: read-only, no advance
read_only = full_stream.attenuate(:color_at)

# Attenuated: limited palette size
limited = full_stream.attenuate(:palette, max: 10)

Commands

just captp-vat seed=1069        # Create vat with seed
just captp-spawn actor_type     # Spawn actor in vat
just captp-send actor method    # Send message
just captp-pipeline expr        # Pipeline expression
just captp-sturdy actor         # Get sturdy reference

Related Skills

References

• Spritely Goblins
• Racket Goblins Docs
• Heart of Spritely Whitepaper
• Hoot: Scheme on WebAssembly
• E Language (historical)

Skill Name: captp Type: Distributed Object Protocol Trit: 0 (ERGODIC) GF(3): Transports capabilities without amplification Invariant: Capabilities unforgeable, only invoke what you're given