THE PLAN: Product & Execution

Problems we want to solve, product direction, milestones, and technical architecture.

The Vision

Core Mission: Create an “import economy” where developers can import live services, not just code.

Like Docker revolutionized deployment with containers, Amigos redefines how apps are composed, shared, extended, and interconnected.

Network Virtualization: Amigos virtualizes not just computers, but the entire network - creating a virtual meta huge worldwide computer where apps can seamlessly connect to each other across any infrastructure.

Problems We’re Solving

Developer Pain Points

Rebuild Everything: Every project starts from scratch
Dead Dependencies: Libraries break, maintainers disappear
Integration Hell: Each service has different APIs, auth, deployment
State Isolation: Can’t fork services with their data/users
Vendor Lock-in: Cloud services trap you in their ecosystem

Market Opportunities

$100B+ Cloud Market: Fragmented, expensive, complex
5.8M Go Developers: Underserved by current platforms
Open Source Fatigue: Companies want hosted solutions
Web3 Infrastructure: Still too complex for mainstream adoption
AI/ML Deployment: Needs simpler, more composable architecture

Product Direction

Phase 1: Import Economy Foundation

Core Platform:

Standard Go imports that work with live services
Copy-on-write state management for service forking
Universal authentication and authorization
Real-time service discovery and composition

Developer Experience:

import "hub.amigos.dev/auth"
import "hub.amigos.dev/payments"
import "hub.amigos.dev/notifications"

func main() {
    user := auth.CurrentUser()
    payment := payments.CreateIntent(user, 1000)
    notifications.Send(user, "Payment created")
}

Usage Experience Examples

Example 1: “Amigoify” an Existing Go Project

Scenario: Taking a standard Go blog application and making it Amigos-compatible

Before (Standard Go):

myblog/
├── blog.go          # Main blog logic
├── server.go        # HTTP server
├── models.go        # Data models
├── handlers.go      # HTTP handlers
└── go.mod

After (Amigos Enhanced):

myblog/
├── blog.go          # Original code unchanged
├── blog.ami.go      # Amigos integration layer
├── server.go        # Original server
├── models.go        # Original models  
├── handlers.go      # Original handlers
├── go.mod           # Original dependencies
└── amigo.yaml       # Amigos configuration

Key Benefits:

Legacy Compatibility: go run, go test, go build still work exactly as before
Zero Breaking Changes: Existing code requires no modifications
Gradual Migration: Add Amigos features incrementally

New Capabilities with Amigos:

# Original Go commands still work
go run .                    # Runs blog locally as before
go test ./...               # Tests pass unchanged
go build .                  # Builds binary as normal

# New Amigos commands unlock additional features  
amigo serve .               # Serves with auto-generated REST API
amigo run .                 # Runs with state management + scaling
amigo push .                # Publishes to Amigos network
amigo publish .             # Makes available for import by others

blog.ami.go (Amigos Integration Layer):

package main

import (
    "github.com/amigos-dev/sdk"
)

// Amigos Service Interface
func (b *Blog) Render() string {
    return sdk.AutoRender(b) // Auto-generates web UI
}

func (b *Blog) State() interface{} {
    return b.posts // Exposes state for forking/importing
}

func (b *Blog) Migrate(old interface{}) error {
    return sdk.AutoMigrate(b, old) // Handles state transitions
}

func (b *Blog) API() sdk.APISpec {
    return sdk.AutoAPI(b) // Generates REST/GraphQL API
}

What You Get For Free:

REST API: Automatic endpoints for all public methods
Web UI: Generated interface for blog management
State Management: Persistent storage with transactions
Scaling: Automatic load balancing and redundancy
Authentication: Built-in user management
Monitoring: Real-time metrics and logging
Importability: Other services can import your blog functionality

Example 2: Building with Imports

Scenario: Creating a startup MVP by importing existing services

package main

import (
    "amigos.dev/auth"           // User authentication service
    "amigos.dev/payments"       # Payment processing
    "amigos.dev/notifications"  # Email/SMS/push notifications
    "amigos.dev/analytics"      # Usage tracking
    "github.com/alice/blog"     # Alice's blog service
    "github.com/bob/comments"   # Bob's comment system
)

type MyStartup struct {
    blog     *blog.Service
    comments *comments.Service
    auth     *auth.Service
}

func (s *MyStartup) CreatePost(title, content string) error {
    user := s.auth.CurrentUser()
    if user == nil {
        return auth.ErrNotAuthenticated
    }
    
    post := s.blog.CreatePost(user, title, content)
    s.comments.EnableFor(post.ID)
    
    analytics.Track("post_created", user.ID)
    notifications.Send(user, "Post published successfully")
    
    return nil
}

func main() {
    startup := &MyStartup{
        blog:     blog.Import("alice/blog:v1.2"),
        comments: comments.Import("bob/comments:latest"),
        auth:     auth.Import("amigos.dev/auth"),
    }
    
    amigo.Serve(startup)
}

Result: Full-featured startup with authentication, blogging, comments, payments, and analytics in <50 lines of code.

Example 3: Service Marketplace

Scenario: Popular services become dependencies

# Discover services
amigo search "authentication"
amigo search "blog" 
amigo search "payments"

# Install and try
amigo import alice/blog:v1.2
amigo import bob/payments:latest

# Test locally  
amigo dev alice/blog
amigo test bob/payments

# Deploy to production
amigo deploy myapp --import alice/blog,bob/payments

Revenue Sharing:

Alice earns fees when others import her blog service
Bob gets paid per payment processed through his service
Platform takes small percentage for hosting and infrastructure

Example 4: Multi-Network Service Lifecycle

Scenario: Building an Amigos-native contract that imports from multiple networks and deploys across environments

Full Import Spectrum:

package main

import (
    // Pure logic from GitHub (traditional)
    "github.com/foo/bar@v1.2.3"           // Git-pinned version
    "github.com/utils/crypto@abc123def"    // Git commit hash
    
    // Blockchain services (Web3)
    "blockchain.land/defi/uniswap"         // Live Uniswap contract
    "blockchain.land/nft/opensea"          // NFT marketplace
    "blockchain.land/dao/governance"       // DAO voting system
    
    // Web2 cloud services
    "aws.land/s3/storage"                  // AWS S3 wrapper
    "aws.land/lambda/functions"            // Serverless functions
    "gcp.land/bigquery/analytics"          // Google BigQuery
    
    // Local development registry
    "local.land/_/my-auth"                 // Local auth service
    "local.land/path/to/payments"          // Local payment handler
    "local.land/_/database"                // Local database service
)

type MultiNetworkApp struct {
    // Traditional logic
    cryptoUtils *bar.CryptoUtils
    
    // Blockchain state & logic
    defi        *uniswap.Pool
    nfts        *opensea.Collection
    governance  *governance.DAO
    
    // Web2 integrations  
    storage     *storage.S3Bucket
    analytics   *analytics.BigQuery
    
    // Local development services
    auth        *auth.Service
    payments    *payments.Processor
    db          *database.Store
}

func (app *MultiNetworkApp) ProcessTransaction(userID string, amount int64) error {
    // Authenticate using local service
    user := app.auth.GetUser(userID)
    if user == nil {
        return errors.New("unauthorized")
    }
    
    // Encrypt data using GitHub logic
    encryptedAmount := app.cryptoUtils.Encrypt(amount)
    
    // Store in Web2 cloud
    receipt := app.storage.Store(fmt.Sprintf("tx_%s", userID), encryptedAmount)
    
    // Execute DeFi transaction on blockchain
    swapResult := app.defi.Swap(user.WalletAddress, amount)
    
    // Record analytics in Web2
    app.analytics.Track("transaction", map[string]interface{}{
        "user_id": userID,
        "amount":  amount,
        "tx_hash": swapResult.Hash,
    })
    
    // Store transaction locally
    app.db.SaveTransaction(user, swapResult)
    
    return nil
}

func main() {
    app := &MultiNetworkApp{
        // Each import resolves to its appropriate network
        cryptoUtils: bar.Import("github.com/foo/bar@v1.2.3"),
        defi:        uniswap.Import("blockchain.land/defi/uniswap"),
        storage:     storage.Import("aws.land/s3/storage"),
        auth:        auth.Import("local.land/_/my-auth"),
        // ... other imports
    }
    
    amigo.Serve(app)
}

Development & Deployment Lifecycle:

# 1. Local Development
amigo init multinetwork-app
cd multinetwork-app

# 2. Add imports from different networks
amigo import github.com/foo/bar@v1.2.3
amigo import blockchain.land/defi/uniswap
amigo import aws.land/s3/storage  
amigo import local.land/_/my-auth

# 3. Local testing with mixed imports
amigo dev .                    # Runs locally, mocks external services
amigo test .                   # Tests with local registry + mocked externals
amigo serve .                  # Local server with hot reload

# 4. Deploy to preview environment
amigo push preview.land/myapp  # Staged deployment for testing
curl https://preview.land/myapp/api/health

# 5. Deploy to production blockchain (requires wallet)
amigo wallet connect           # Connect Web3 wallet
amigo deploy blockchain.land/myapp --wallet 0x123...
# Transaction hash: 0xabc123def...
# Service live at: blockchain.land/myapp

Network Resolution Examples:

# Different import schemes resolve to different networks
github.com/foo/bar@hash       → Git repository (static)
blockchain.land/foo           → Smart contract (live state)
aws.land/bar                  → Cloud service (managed)
local.land/_/baz              → Local registry (development)
preview.land/test             → Staging environment (testing)

What Makes This Powerful:

Network Abstraction: Same import syntax works across Web2, Web3, and local
Environment Progression: Seamless promotion from local → preview → production
Mixed Architectures: Combine traditional code, cloud services, and blockchain in one app
Network-Aware Testing: Local development with appropriate mocking/simulation
Wallet Integration: Blockchain deployments require proper authentication
State Management: Each network handles persistence appropriately

Registry Behaviors:

local.land/_/: Local development registry (file-based)
preview.land/: Staging environment (centralized, ephemeral)
blockchain.land/: Production blockchain (decentralized, permanent)
aws.land/: Web2 cloud proxy (managed service integration)
github.com/: Traditional code imports (static, versioned)

CLI Experience: Docker + IPFS Simplicity

Unified CLI Design: Composable commands that feel familiar to Go/Docker/IPFS users.

Core Commands:

# Development workflow
amigo build .              # Build service from current directory
amigo serve .              # Serve with auto-generated APIs
amigo push .               # Push to registry
amigo pull remote.land/foo # Import remote service
amigo call remote.land/foo # Execute remote service
amigo publish .            # Make available for others to import

# Network exploration
amigo map                  # Show network topology
amigo why foo              # Explain service dependencies
amigo connect foo          # Establish service connection

# Multi-scheme support
amigo pull https://service.com/api
amigo pull ./local/service
amigo pull newscheme://distributed.service

Experience Goals:

Go-like: Standard binary commands for familiar operations
Docker-like: Build/execution workflow developers understand
Blockchain-like: Network requests and state queries
Unified: One CLI for all network operations

Phase 2: Progressive Decentralization

Web2 → P2P → Blockchain:

Start with centralized hub for speed
Add P2P networking for resilience
Blockchain for governance and value transfer
Maintain simple Go import syntax throughout

Phase 3: Network Effects

Ecosystem Growth:

Every app becomes both standalone AND a dependency
Revenue sharing for imported services
Automatic scaling and optimization
Community-driven service marketplace

Technical Architecture

Core Components

Amigos Hub:

Service registry and discovery
Authentication and authorization
State management and persistence
Inter-service communication

Amigos Runtime:

Go module integration
Service lifecycle management
Resource allocation and scaling
Network routing and load balancing

Amigos CLI:

Service development and deployment
Local testing and debugging
State management and migration
Performance monitoring

Development Tools:

Static analyzer/formal proof: Built-in verification by default
Graphviz explorers: Visual dependency graphs for code, state, and execution flow
Network mapping: Real-time topology and connection visualization
Dependency analysis: “Why” commands for understanding service relationships

Hub Network (amigos.hub):

Ecosystem configuration: Centralized registry for essential settings
Network whitelist: Trusted network validation and discovery
Version registry: Current software versions and upgrade paths
Name resolution: Short handles for usernames and domain names
Governance coordination: Community decision-making infrastructure

Service Model

Every Service Provides:

type Service interface {
    Render() string        // Universal UI rendering
    State() interface{}    // Current state export
    Migrate(old) error     // State migration
    Health() Status        // Health check
}

Every Service Gets: