For developers

Give your systems ranked next-action JSON.

KynticAI turns raw events, identity matches, timestamped paths and outcome weights into one clean contract for staff tools, portals, APIs and approved AI agents.

Use Scout locally. Move to Fortress for a private billions-scale relationship runtime. Use Elite for the full operating model with an included open-source model route and no extra token costs.

Open Scout on GitHubSee the Context Engine

Context packet

Illustrative synthetic developer payload

Ready
{
  "subject": "technical_buyer_enquiry",
  "identity_relationships": {
    "canonical_index": "lead_cluster_8841",
    "matched_aliases": ["Paul Madd", "Paul Maddison"],
    "data_quality_state": "merged_at_same_index"
  },
  "relationship_path": [
    {
      "event": "visited_homepage",
      "timestamp": "2026-08-09T09:14:00Z",
      "attribution_weight": 0.31
    },
    {
      "event": "read_context_engine",
      "timestamp": "2026-08-09T09:17:00Z",
      "attribution_weight": 0.57
    },
    {
      "event": "opened_fortress",
      "timestamp": "2026-08-09T09:22:00Z",
      "attribution_weight": 0.72
    }
  ],
  "recommended_actions": [
    {
      "action": "route to design-partner qualification",
      "confidence": 0.68,
      "reason": "similar paths converted after fast technical proof"
    }
  ],
  "reasoning_prompt": "KynticAI proprietary prompt",
  "handoff": ["staff_brief", "portal_response", "api_payload", "ai_agent_packet"]
}
identity_relationships
relationship_path[]
attribution_weight
similar_outcomes
recommended_actions[]
confidence
source_trail
caveats
reasoning_prompt
handoff

Builder payoff

One evidence contract. Four places to use it.

The same ranked context packet can drive a staff recommendation, a portal response, an API workflow or an AI-agent instruction without losing provenance.

Read the architecture

Identity relationships handle dirty data such as Paul Madd and Paul Maddison.

Timestamped paths preserve the order of what happened.

Attribution weights show which signals caused conversion, risk, drop-off or escalation.

Build path

Start with proof. Move to private scale. Finish with the operating model.

API shape

Boring integration. Powerful output.

Developers should not need magic ceremony. Register events, request context, receive the ranked packet, then pass it into the interface or workflow that needs the next move.

REST

POST /v1/context/next-action
{
  "subject_id": "lead_cluster_8841",
  "workflow": "homepage_enquiry",
  "return": ["staff_brief", "api_payload", "ai_agent_packet"]
}

GraphQL

query NextAction($subjectId: ID!) {
  nextActionContext(subjectId: $subjectId) {
    confidence
    recommendedActions { action predictedSuccess }
    sourceTrail { event timestamp attributionWeight }
    handoff { staffBrief portalApiPayload aiAgentPacket }
  }
}

Scout GraphQL examples

Useful queries for the first developer proof.

These examples show the kind of Scout operations developers care about first: read context, inspect relationships, ask for ranked next actions and register new source events. Fortress and Elite extend this with customer-specific API, connector and deployment support.

Read a context snapshot

Use this when a staff tool, internal portal or local AI workflow needs the current governed context for one subject.

query ScoutContextSnapshot($tenant: String!, $subjectId: ID!) {
  contextSnapshot(tenantSlug: $tenant, subjectId: $subjectId) {
    subject { id label type }
    confidence
    facts {
      key
      value
      provenance { sourceSystem fieldPath timestamp }
    }
    caveats
  }
}

Inspect relationship paths

Use this to debug why Scout believes two records, identities, events or outcomes belong in the same relationship set.

query ScoutRelationshipPath($tenant: String!, $subjectId: ID!) {
  relationshipPaths(tenantSlug: $tenant, subjectId: $subjectId) {
    pathId
    nodes { id label kind }
    edges { from to relationship timestamp attributionWeight }
    sourceTrail { sourceSystem recordId citationId }
  }
}

Ask for ranked next actions

Use this when you want the JSON that a staff brief, portal/API response or approved AI agent can consume.

query ScoutNextActions($tenant: String!, $subjectId: ID!, $workflow: String!) {
  nextActionContext(
    tenantSlug: $tenant
    subjectId: $subjectId
    workflow: $workflow
  ) {
    recommendedActions {
      action
      predictedSuccess
      predictedRisk
      evidence { event timestamp attributionWeight }
    }
    handoff { staffBrief portalApiPayload aiAgentPacket }
    caveats
  }
}

Register a source event

Use this when a local app, CRM simulator, workflow runner or integration test needs to add timestamped evidence into Scout.

mutation RegisterScoutSourceEvent($tenant: String!, $input: SourceEventInput!) {
  registerSourceEvent(tenantSlug: $tenant, input: $input) {
    accepted
    eventId
    relationshipSetId
    validationMessages
  }
}

Handoff targets

Not just AI agents. Your people and systems use it too.

Staff brief

A human-readable next-action brief with confidence, caveats and source trail.

Portal/API payload

A deterministic JSON packet your own systems can render, store, queue or audit.

AI-agent packet

A ranked decision context that tells approved agents what to do next and why.

Developer docs

Start from the repo docs, then build the first packet.

The live product story is simple, but developers need the concrete trail: local setup, API contract, SDKs, connectors, webhook events, consumers and support. These links go to the public Scout repo docs.

Developer help

If you are wondering where to begin, pick the route that matches the job.

I want to test the idea locally

Start with Scout. Use the docs to shape one source, one workflow and one outcome before expanding the data set.

Open Scout →

I need production scale

Use Fortress when you need private connectors, billions of relationship data points, high-load traversal, governance, deployment-specific performance validation and custom developer support.

See Fortress →

I need the enterprise operating route

Use Elite when leadership wants the full operating model, outcome cadence, approved open-source model route, no extra token costs and custom developer support around the customer operating model.

See Elite →

I need implementation help

Bring one target workflow and the systems involved. KynticAI can help map the first relationship packet and the handoff route.

Ask for help →

Commercial developer support

Scout is the free public route with repo docs and local proof material. Fortress and Elite include custom developer support for private connectors, data-plane boundaries, API handoff design, deployment validation, performance evidence and the exact customer operating workflow.

Scout / Fortress / Elite

The same packet, scaled by product.

CapabilityScoutFortressElite
Ranked next-action JSON packet✓✓✓
Identity/data-quality relationship matching✓✓✓
Timestamped attribution paths✓✓✓
GraphQL + REST API✓✓✓
TypeScript + C# integration path✓✓✓
PostgreSQL proof store✓✓✓
Private sovereign runtime—✓✓
Billions of relationship data points—✓✓
Canonical Rust relationship/weighting/traversal engine—✓✓
LanceDB high-load vector store—✓✓
OIDC, SCIM, SAML and enterprise governance exports—✓✓
Air-gapped / private deployment path—✓✓
Leadership operating model——✓
Included open-source model route with no extra token costs——✓

Start building

Clone Scout. Prove the JSON. Then decide how far you want to scale.

The developer path is deliberately simple: local proof first, private production runtime second, full enterprise operating model when the business wants the whole flywheel live.

View Scout on GitHubRequest Fortress / Elite access