Load

Your data

Connectors or approved imports bring in emails, cookies, events, CRM rows, tickets, billing, documents, and outcomes.

Store

The trail

Scout keeps ordered attribution paths in your estate (PostgreSQL/pgvector for proof). Fortress moves heavy load into Rust and LanceDB.

Match

Past outcomes

The Rust engine compares the current path with similar journeys that converted, retained, escalated, delayed, or lost.

Return

A task brief

Checked JSON with top examples, confidence, caveats, and ranked next steps for the goal you asked about.

Explain

Your model or team

Your approved model can explain the brief. It does not invent the plan. Elite covers the leadership walkthrough when needed.

Context Engine map →

Architecture / Scout

The free open-source data plane for proving Context Engine relationship memory.

Scout is the free, open-source Context Engine path: inject data items, define selectors, store attribution paths and behavioural path vectors in PostgreSQL/pgvector, assemble relationship facts, and expose schema-validated execution packet through clean APIs before any enterprise deployment expands.

View ScoutPlatform Architecture

Core layers

How Scout is structured

01

Free open-source data-item injection

Describe local databases, APIs, files, approved import packs, and system boundaries in a repeatable data-plane model buyers can inspect before Enterprise/Fortress.

02

PostgreSQL/pgvector operational-path proof store

Create facts through deterministic mappings and store the ordered path, identity links, event order, and behavioural path vectors for each item in Scout's PostgreSQL/pgvector operational-path path.

03

Developer APIs

Expose snapshots, relationship facts, attribution paths, schema-validated execution packet, and task output through REST, GraphQL, admin surfaces, SDKs, webhooks, and local developer tooling.

Operating flow

The request path through the product

Inject

Systems stay where they are

SQL, CRM, ERP, SharePoint, email engagement, cookies, web events, support, billing, usage, and outcome systems remain under customer control.

Store

Relationships gain attribution

Scout stores each item in PostgreSQL/pgvector for inspectable proof. Fortress uses the Rust/LanceDB runtime when the relationship memory needs high-load enterprise relationship traversal.

Explain

The right model gets JSON, not data sprawl

Fortress feeds the customer's approved model endpoint; the Elite path can show how local/private open-source model routing would fit where approved.

Example signal path

Scout proves data items can become schema-validated execution packet

Illustrative sample data only. A real pilot would agree source scope and measurement before use.

01 / Source

Example fields

SQLite.email = testname@test.com

SQLite.cookie = web_cookie_4281

SQLite.web_search = page_a

SQLite.product_interest = product_b

02 / Evidence

What KynticAI creates

attributionPath = email -> page_a -> product_b

similarPattern = email + page_a + product_b

selector = WeightedScoring

snapshot_id = next-task-1042

03 / Action

What the business does

call REST relationship endpoint

show schema-validated execution packet

scope pilot around reuse

Operating model

How the product stays useful at enterprise scale

Identity

Access follows enterprise roles

Fortress patterns align evidence access with customer identity, role boundaries, and local administration.

Audit

The source trail stays visible

Governance control surfaces and export paths focus on what was read, why it was used, and which policy applied.

Sovereignty

Customer data plane owns operational data

KynticAI can manage licences, support, updates, and aggregate posture while the customer data plane owns operational data.

Integration points

Where it connects to the wider stack

Scout

Free open source

Scout proves the Context Engine data-plane mechanics with source registration, selectors, snapshots, relationship facts, PostgreSQL/pgpath-weight storage, JSON output, and APIs before enterprise deployment.

Enterprise

Rust/LanceDB engine

Enterprise adds the proprietary Rust relationship, weighting, traversal, and LanceDB outcome path matching engine plus private runtime controls and sovereign storage patterns.

Operate

KynticAI operations layer

KynticAI manages commercial metadata, licences, downloads, support, aggregate posture, and updates without raw customer records.

Product Reveals

Context Engine turns source-traced relationships into governed JSON.

These examples focus on Scout proof, Fortress private runtime, Elite executive walkthroughs, and governed JSON output.

KynticAI Reveal
Free Open Source

Scout scenario - SQL row, source event, attribution path

Prove Context Engine free

“A buyer can inject authorised rows, browser events, emails, and product signals into Scout before committing to the enterprise runtime.”
KynticAI Reveal
PostgreSQL/pgvector

Scout scenario - lower-load vector proof store

Readable proof before scale

“Scout stores relationship facts, attribution paths, and behavioural path vectors in PostgreSQL/pgvector so the team can inspect what the layer is doing.”
KynticAI Reveal
JSON Output

Scout scenario - API, snapshot, relationship fact, next task

Give the model evidence it can explain

“The output is not vague context. It is governed JSON with the item path, examples, confidence, caveats, and ranked task options.”