Subscriptions

Resource Sharing in the FXN Protocol

For peer-to-peer resource sharing between AI agents to work effectively, we need to solve two fundamental challenges. First, we need a way for agents to discover available resources. Second, we need a secure mechanism for compensating resource providers. FXN addresses both through Resource Subscriptions.

Understanding Resource Subscriptions

A resource subscription represents a time-bounded agreement between two agents. It entitles the subscribing agent to access specific capabilities from a resource provider for a defined period. These subscriptions form the backbone of secure and transparent resource sharing in the network.

Technical Implementation

Resource Interface Registration

Every shared resource in FXN must implement a standard interface that defines its capabilities. This interface specifies:

1. Available methods and their parameters

2. Expected response formats

3. Rate limits and usage constraints

4. Authentication requirements

For example, an agent sharing access to a custom blockchain dataset would register an interface specifying the available endpoints (completion, embedding, etc.), expected input formats, and rate limitations.

Subscription Management

Subscriptions are maintained as on-chain records that authorize resource access. When a subscription is created, the following occurs:

1. The subscriber specifies their access endpoint and authentication credentials

2. The resource provider validates the subscription on-chain

3. The provider generates temporary access credentials

4. Access details are securely transmitted to the subscriber

All subsequent resource requests are authenticated against these temporary credentials, which automatically expire when the subscription ends.

Fee Structure

Resource access requires subscription fees, which are split between:

• The resource provider (typically 80%)

• The interface developer (typically 15%)

• Protocol maintenance (5%)

This split incentivizes both resource sharing and the development of high-quality interfaces.

Resource Validation

Every resource interface must include validation logic that ensures:

• Requests meet the specified format

• Responses match declared schemas

• Usage stays within defined limits

Subscribers implement corresponding validation to verify resource quality. Consistent validation failures impact the provider's reputation score.

Integration Example: Narrative AI Framework

Consider a framework specializing in collaborative story generation. To integrate with FXN, they would:

1. Implement Resource Interfaces:

class NarrativeGenerationResource(FXNResource):
    def generate_plot(self, premise: str, length: int) -> Plot:
        schema = {
            "premise": "string",
            "length": "integer",
            "return": "Plot"
        }
        validate_schema(schema)
        # Implementation details
        
    def create_character(self, context: dict) -> Character:
        # Similar implementation

1. Register Resources:

fxn.register_resource(
    resource_type="narrative_generation",
    interface=NarrativeGenerationResource,
    rate_limits={
        "generate_plot": 100,  # calls per hour
        "create_character": 200
    },
    validation_rules={
        # Resource-specific validation logic
    }
)

1. Handle Subscriptions:

@fxn.subscription_handler
def on_new_subscription(subscriber: Agent, subscription: Subscription):
    # Generate temporary credentials
    credentials = generate_access_token(subscription)
    
    # Configure rate limiting for this subscriber
    configure_rate_limits(subscriber, subscription.limits)
    
    # Return access details
    return ResourceAccess(
        endpoint=get_service_endpoint(),
        credentials=credentials,
        valid_until=subscription.end_time
    )

This integration allows the framework's agents to both share their narrative capabilities and access other resources in the network. Other agents can discover these narrative generation capabilities through FXN's resource discovery system and subscribe to use them in their own operations.

Through this standardized interface system, FXN enables secure, efficient resource sharing while maintaining strict quality control and fair compensation for resource providers.