Product / KynticAI Scout
The free, open-source layer above any authorised company data set.
Scout is the free, open-source entry point to the Universal Context Layer (UCL): it injects authorised data items through connectors or approved one-off imports, stores those items as relationship sets with attribution paths in PostgreSQL/pgvector, and exposes governed JSON for the LLM that explains what task should happen next.
Start free and open source, put a sovereign relationship memory above company data, then ask it the best way to achieve a goal.
Buyer spark
Start free. Prove the layer. Make the enterprise sale obvious.
Scout gives a buyer the first hit of belief: one authorised source becomes relationship memory, then relationship memory becomes JSON a model can explain.
No vague AI promise: the buyer can inspect the source, selector, relationship fact, and JSON.
The free open-source path makes the first conversation easier because the product is tangible.
When Scout hits proof scale, Fortress and Elite become the natural upgrade instead of a cold upsell.
Plain English
What Scout does and how the relationships support the next task.
What it does
Scout is free and open source. It sits above authorised company data and turns ordinary records, cookies, events, email addresses, products, accounts, and outcomes into relationship sets an AI workflow can use.
How it works
You inject data items, identify the object they belong to, preserve the ordered attribution path, store vectors in PostgreSQL/pgvector, compare similar relationship sets, and expose governed JSON through clean APIs.
Commercial value path
It lets buyers prove one high-value question locally, such as how to convert this email enquiry, before moving into Enterprise/Fortress for the private Rust/LanceDB runtime.
Task moment
An email, a cookie, a web search, and product interest become: here are the top examples, here is the best task, and here is why.
What you get
The concrete deliverables behind Scout.
Free open-source entry point
Scout can be run and inspected without a licence fee so buyers can prove the Universal Context Layer mechanics before Enterprise/Fortress deployment.
Data-item injection
A local data-plane path for authorised connector loads plus approved one-off imports or mapping work, including Claude/Codex-assisted preparation when the customer permits it.
Item attribution paths
Store the ordered path for a customer, email address, cookie, browser event, product, account, or case: what happened, when it happened, and which source proved it.
Relationship-set JSON
REST and GraphQL-shaped output that carries cited data items, attribution path, similar examples, confidence, caveats, and ranked task options for a selected goal.
Proof-scale PostgreSQL/pgvector store
Scout uses PostgreSQL/pgvector for the free open-source path. Use it for developer proof, first-source validation, and lower-load pilots, not high-concurrency or high-performance vector-search installations.
Enterprise upgrade route
A clear path from free open-source Scout into Enterprise/Fortress private connectors, proprietary Rust/LanceDB relationship analysis, LanceDB-backed vector storage, sovereign deployment, and stronger governance.
Example data walkthrough
Sales next-best task from an email enquiry and product-interest trail
Privacy-safe synthetic example backed by a real validation path. Customer pilots replace the sample data with authorised source systems and agreed success measures.
01 / Source row
Scout injects the authorised data items
email = testname@test.com
cookie = web_cookie_4281
event = email_enquiry
web_search = page_a
product_interest = product_b
crm_status = new enquiry
outcome_history = converted / did_not_convert
A normal enquiry becomes an item with identity, event history, and enough context to compare against previous similar journeys.
02 / Relationship facts
The attribution path becomes searchable memory
attributionPath = email_enquiry -> page_a -> product_b
sameEmailPattern = matched
sameProductBrowse = matched
registeredAccount = not_yet
abstractPattern = email enquiry + generic web search
Scout can prove the relationship memory in PostgreSQL/pgvector; Enterprise/Fortress moves the same pattern into the Rust/LanceDB runtime for high-volume comparison.
03 / Money move
The top examples become task JSON
topExample = previous email + page_a + product_b conversion path
option_1 = send follow-up email | estimated_probability = 72%
option_2 = ask user to register account | estimated_probability = 61%
Fortress handoff = JSON to customer LLM
Elite handoff = on-prem open-source LLM
The LLM receives a JSON file with the best examples and turns it into a text explanation of what to do next.
How it works
The private data plane above the systems you already own
Scout is the free, open-source Universal Context Layer (UCL) data-plane path. It injects authorised data items, stores relationship sets, ordered attribution paths, and vectors in PostgreSQL/pgvector, assembles similar examples for the goal, and exposes JSON to consumers while keeping customer data under local control.
Connectors or one-off imports
Describe databases, APIs, files, customer-approved import packs, and system boundaries while the customer data plane remains the owner of raw records.
PostgreSQL/pgvector proof store
Use repeatable mappings to store data items, identity links, source order, purpose, provenance, vectors, and the path each item took in the inspectable Scout data plane.
Similar relationship sets
Find same or abstract relationships such as same email, same product browse, same registration path, or email enquiry plus generic web search.
Top-example JSON
Expose snapshots, top examples, relationship facts, and task-ready JSON through REST, GraphQL, admin UI, webhooks, and downstream model clients.
What this unlocks
The practical moves that make Scout worth paying for
Domain entities
Represent customers, email addresses, cookies, browser events, assets, tickets, deals, cases, products, or any operational object that needs relationship memory.
Attribution paths
Store the order of events and sources for each item so the system knows what happened before the goal was reached or missed.
Selector engine
Turn authorised source fields into relationship facts with repeatable mappings instead of fragile prompt glue.
Clear sizing boundary
Use Scout up to proof, developer, and lower-load pilot scale. Around 100,000 relationship/vector records, 250,000 source events a month, high concurrent search, or any P95/P99 performance requirement, move the buyer to Fortress or Elite.
JSON task handoff
Assemble top-example JSON for a specific question, goal, entity, use case, or agent request, with provenance, confidence, caveats, and task options.
Developer console
Inspect sources, selectors, facts, and API output from a React admin surface built for engineers.
Integration points
Designed to sit inside the enterprise stack you already own
Local systems
SQLite, PostgreSQL/pgvector, SQL databases, REST APIs, GraphQL endpoints, flat files, and developer-controlled test fixtures.
Product operations registration
Register status, entitlement posture, update checks, and aggregate-only usage while operational records remain in the customer data plane.
Enterprise path
Promote proven free open-source Scout deployments into Enterprise/Fortress patterns with the proprietary Rust/LanceDB relationship engine, LanceDB vector database, private connectors, vaults, identity, and restricted-environment planning.
Back to the platform story