cmd/nex/main.go           # Entry point, Kong CLI parsing
  └─ cmd/nex/workload.go  # `nex workload start` handler
       └─ client/client.go
            ├─ Auction()           # Bid for workload placement
            └─ StartWorkload()     # Deploy to winning bidder

node/node.go: NewNexNode()     # Create node with identity
  └─ node/node.go: Start()     # Start NATS handlers
       └─ node/handlers.go     # NATS microservice endpoints
            ├─ handleAuction()              # Respond to auction requests
            ├─ handleAuctionDeployWorkload() # Mint creds + deploy
            └─ handleAgentRegister()        # Accept agent registration

agent/agent.go: Agent interface   # 9 required methods
  └─ Register()                   # Declare capabilities
  └─ StartWorkload()              # Deploy + emit WorkloadStartedEvent
  └─ StopWorkload()               # Terminate + emit WorkloadStoppedEvent
  └─ Heartbeat()                  # Report health every 30s

_test/nexlet_inmem/inmemagent.go  # Reference implementation

type Agent interface {
    // Lifecycle
    Start(ctx context.Context) error
    Stop() error

    // Registration
    Register(parentId string) error
    AgentID() string

    // Workload management
    StartWorkload(request *StartWorkloadRequest) (*WorkloadInfo, error)
    StopWorkload(workloadId string) error
    ListWorkloads() ([]WorkloadInfo, error)

    // Health
    Heartbeat() AgentHeartbeat
}

node/minter.go: SigningKeyMinter
  └─ Mint()                       # Create JWT with scoped permissions
       └─ WorkloadClaims()        # Pub: _INBOX.>, Sub: logs.{ns}.>, _INBOX.>

┌─────────────────────────────────────────────────────────────────────┐
│                         NEX Architecture                             │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────────────────┐  │
│  │   Client    │───▶│  NexNode    │───▶│   Agent (Nexlet)        │  │
│  │  (CLI/SDK)  │    │  (Host)     │    │   (Runtime Executor)    │  │
│  └─────────────┘    └─────────────┘    └─────────────────────────┘  │
│        │                  │                       │                  │
│        │    1. Auction    │    2. Deploy          │    3. Execute    │
│        ▼                  ▼                       ▼                  │
│  ┌─────────────────────────────────────────────────────────────────┐│
│  │                    NATS Messaging Fabric                         ││
│  │  $NEX.SVC.<namespace>.control.*  (auction, deploy)               ││
│  │  $NEX.FEED.<namespace>.event.*   (lifecycle events)              ││
│  │  $NEX.FEED.<namespace>.logs.*    (workload logs)                 ││
│  └─────────────────────────────────────────────────────────────────┘│
└─────────────────────────────────────────────────────────────────────┘

// Get wiki structure
mcp__deepwiki__read_wiki_structure({ repoName: "synadia-io/nex" })

// Ask about specific components
mcp__deepwiki__ask_question({
  repoName: "synadia-io/nex",
  question: "How does the auction system work?"
})

// Explore agent interface
mcp__deepwiki__ask_question({
  repoName: "synadia-io/nex",
  question: "What methods must an agent implement?"
})

// Understand credential minting
mcp__deepwiki__ask_question({
  repoName: "synadia-io/nex",
  question: "How are workload credentials scoped?"
})

// Node events
type NexNodeStartedEvent struct { ... }
type NexNodeStoppedEvent struct { ... }

// Agent events
type AgentStartedEvent struct { ... }
type AgentStoppedEvent struct { ... }

// Workload events
type WorkloadStartedEvent struct {
    WorkloadId    string
    NodeId        string
    WorkloadName  string
    Namespace     string
    Type          string
    Lifecycle     string
}
type WorkloadStoppedEvent struct { ... }
type WorkloadTriggeredEvent struct { ... }  // For functions

{
  "node_name": "my-node",
  "nexus": "default",
  "tags": {
    "env": "production",
    "region": "us-west"
  },
  "agents": ["native"],
  "nats": {
    "servers": ["nats://localhost:4222"],
    "credentials": "/path/to/creds.creds"
  },
  "events": {
    "destinations": ["nats", "logs"]
  }
}

name: my-workload
type: native
lifecycle: service
description: My workload description
tags:
  env: production
start_request:
  uri: "file:///path/to/binary"
  argv: ["--config", "/etc/app.yaml"]
  environment:
    LOG_LEVEL: "debug"
  workdir: "/app"

// _test/nexlet_inmem/inmemagent.go

type InMemoryAgent struct {
    id        string
    parentId  string
    workloads map[string]*WorkloadInfo
    nc        *nats.Conn
}

func (a *InMemoryAgent) Register(parentId string) error {
    a.parentId = parentId
    // Register capabilities with parent node
    return a.nc.Publish(
        fmt.Sprintf("$NEX.SVC.%s.agents.REGISTER", a.parentId),
        registerPayload,
    )
}

func (a *InMemoryAgent) StartWorkload(req *StartWorkloadRequest) (*WorkloadInfo, error) {
    // Validate request
    // Start execution
    // Return workload info
}