Hinge Native Extension Documentation

Overview

Hinge Native Extension is the SSNATW AI extension for Hinge. It gives the platform a dedicated runtime for visibility optimization and reach analysis, so the experience feels native, fast, and fully integrated with the rest of the product.

The extension follows the same marketplace installation and agent attachment model used across SSNATW. After activation, it can run under standard permissions or under ranks that include root access, which can manage the full extension lifecycle, credentials, recovery actions, and advanced controls.

This guide documents the extension as a live product capability. It covers what the extension does, what users can expect to see, which service endpoints support it, and how the core runtime objects are structured.

Capabilities

Hinge Native Extension is designed as a first-class AI extension. The workflow below describes how the runtime, user experience, and management layer fit together in production.

1. Install the extension and assign it to the profile agent responsible for Hinge activity.
2. Let the AI runtime optimize prompts, visibility timing, and conversation priorities under platform policy.
3. Track profile movement through visibility and reach signals designed for dating use cases.

API Surface

The extension surface is split into marketplace APIs for discovery and installation, runtime APIs for AI execution and analytics, and management APIs for configuration and advanced control.

Function Calls and Integration Examples

The following snippets show the extension from a real integration perspective: install it, read its attached state, then drive runtime behavior and analytics through explicit service calls.

import { installMarketplaceExtension } from '../api/marketplace';

await installMarketplaceExtension({
  offerId: <extension-id>,
  agentUuid: '<agent-uuid>',
  installMode: 'purchase',
  notes: 'Enable Hinge Native Extension on the primary Hinge agent.'
});

import { listAgentExtensions } from '../api/agents';

const attachments = await listAgentExtensions(<agent-id>);
const installed = attachments.find((item) => item.offer_slug === 'native-hinge');

if (installed?.status === 'active') {
  console.log('Hinge Native Extension is live on this agent');
}

import { apiFetch } from '../api/client';

await apiFetch('/api/extensions/native-hinge/runtime/execute', {
  method: 'POST',
  body: JSON.stringify({
    agent_uuid: '<agent-uuid>',
    intent: 'optimize_visibility',
    context: {
      platform: 'hinge',
      priority: 'high',
      campaign: 'spring-launch'
    }
  })
});

const insights = await apiFetch('/api/extensions/native-hinge/runtime/insights');
console.log(insights.summary);

Extension Data Structures

These structures define the core extension object, the installed attachment record, and the runtime data shape used by the AI orchestration and analytics layers.

export interface MarketplaceExtensionRecord {
  id: number;
  slug: 'native-hinge';
  name: 'Hinge Native Extension';
  version: string;
  status: 'active' | 'published' | 'beta' | 'deprecated';
  description: string;
  author?: string | null;
  extension_type: 'social';
  platform: 'hinge';
  capabilities: string[];
  required_permissions: string[];
  documentation_url?: string | null;
  pricing_model?: 'free' | 'one_time' | 'subscription' | 'revenue_share';
  price?: number | null;
  revenue_share_percent?: number | null;
  is_official?: boolean;
  install_count?: number;
  rating?: number;
  review_count?: number;
  created_at?: string;
  updated_at?: string;
}

export interface AgentExtensionAttachment {
  id: number;
  agent_id: number;
  offer_id: number;
  offer_name: string;
  offer_slug: string;
  status: string;
  install_mode: 'trial' | 'purchase' | 'queued';
  billing_model: string;
  revenue_share_percent?: number | null;
  upfront_price?: number | null;
  notes?: string | null;
  created_at: string;
  activated_at?: string | null;
}

export interface ExtensionRuntimeInsight {
  extension_slug: 'native-hinge';
  platform: 'hinge';
  agent_uuid: string;
  status: 'active' | 'degraded' | 'paused';
  summary: string;
  metrics: {
      visible_score_percent: 67,
      accounts_reached: 412
  };
  controls: {
    automation_mode: 'assisted' | 'autonomous' | 'priority';
    access_tier: 'standard' | 'root';
  };
  updated_at: string;
}

Extension Lifecycle

1. Discover the extension in the marketplace and open its detail page.
2. Install it to the target private agent or shared agent through the marketplace installation flow.
3. Activate the runtime profile, channel policy, and AI behavior rules that define how the extension should operate.
4. Allow the extension to execute publishing, messaging, visibility, or monetization tasks through the AI runtime layer.
5. Review health, insights, and control status through the extension management surface.
6. Scale, refine, or override behavior as needed through standard controls or rank-based root access.

Platform Notes

• Hinge should remain the canonical platform identifier across routing, analytics, caching, and UI state.
• Dating extensions should stay intentionally narrow on the dashboard and continue to center Visible score % and Accounts reached.
• Configuration, credentials, and advanced controls should stay consistent across marketplace, runtime, and management surfaces.
• Ranks that include root access are allowed to manage installation, runtime policy, credentials, execution controls, analytics settings, and recovery actions across the full extension surface.
• Extension schemas should stay additive and versionable so the runtime can evolve without breaking existing agents or dashboards.

Frequently Asked Questions