Product / KynticAI Scout
The free, open-source layer above any authorised company data set.
Scout is the free, open-source entry point to KynticAI Context Engine: 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.
Sales path / Scout proof
The Scout demo question: which next task follows this enquiry?
Scout should sell itself in one walkthrough. The buyer brings one enquiry, sees the relationship path, inspects the JSON, and understands why Fortress becomes the next commercial step when the proof needs scale.
Question: this person emailed us, looked at the pricing page, then read integrations. What should the sales team do next?
1. Data in
Scout starts with a proof-sized set of authorised records.
email = maya.chen@example.invalid
event = inbound_email_enquiry
web_path = pricing -> integrations -> security
crm_stage = new_opportunity
outcomes_available = converted, registered, no_response
2. Relationship path
The enquiry becomes a journey the buyer can inspect.
identity = email + cookie + CRM lead
path = email_enquiry -> pricing -> integrations -> security
matched_examples = similar technical-buyer journeys
caveat = procurement owner not yet known
3. JSON handoff
Scout returns a small task brief instead of a dashboard.
top_example = converted technical enquiry
option_1 = send integration proof
option_2 = ask user to register account
review = confirm buyer role
Output
Illustrative LLM task brief from Scout JSON
Next task: send the integration proof and security note before asking for budget.
Registration path: offer a trial workspace only after the buyer confirms their role.
Review note: procurement owner is missing, so keep proposal language out of the first reply.
Scout makes the first proof tangible: one email enquiry becomes a ranked sales action with source trail, caveat, and next-step options.
Data in, data out
Scout shows the simple version: business data in, next-task JSON out.
A buyer should be able to understand Scout in one minute. It takes approved data from one workflow, joins the pieces into a relationship path, then returns a JSON brief a person or model can use.
Approved records enter
Start with a small set of permitted CRM rows, emails, web events, support tickets, product signals, or outcomes.
Scout links the journey
Scout connects each signal to the account, customer, case, product, or event it belongs to.
Similar paths are compared
The system looks for previous journeys that had a similar pattern and a known outcome.
A task brief comes out
The output is inspectable JSON: what happened, which examples matter, what to do next, and which caveats need review.
Example input
Sales enquiry proof
email enquiry from buyer@example.com
visited pricing page and integration page
CRM status = open opportunity
previous similar enquiries with converted and lost outcomes
Example output
object = buyer enquiry
matched_path = enquiry -> pricing -> integration interest
next_task = send technical follow-up with integration proof
caveat = confirm procurement owner before proposal
Buyer result
The buyer sees Scout turn scattered source records into a concrete next sales task without needing a heavy enterprise deployment first.
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 or the proposed Elite route becomes a natural next conversation 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 Context Engine 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 approved AI-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 | priority = high
option_2 = ask user to register account | priority = medium
Fortress handoff = JSON to approved model boundary
proposedEliteRoute = executive walkthrough where approved
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 Context Engine 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, human decision, or AI 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