Product / KynticAI Scout
Prove the path on your machine before you buy anything.
Scout is free and open source. It takes authorised cookies, emails, and events, keeps ordered paths in PostgreSQL/pgvector, and returns checked JSON so a person or a model can see the next task. It does not invent the plan from loose document chunks.
Start free: data in, paths stored, next task packet out.
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 an analytics view.
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 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 sits above the systems you already have and turns ordinary records, cookies, events, and outcomes into relationship trails a workflow can use.
How it works
You load items, keep the order of what happened, store paths in PostgreSQL/pgvector, match similar journeys, and expose JSON through clean APIs.
Commercial value path
You prove one real question locally, such as how to convert this enquiry, before moving to Fortress for a private Rust and LanceDB runtime.
Task moment
An email, a cookie, a page view, and product interest become: here are similar cases, here is the next 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 path-matching installations.
Enterprise upgrade route
A clear path from free open-source Scout into Enterprise/Fortress private connectors, proprietary Rust/LanceDB relationship analysis, LanceDB-backed path-weight 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 traversable operational 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 behavioural path 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 operational-path 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.
Schema-validated execution packet
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 ad-hoc instruction glue.
Clear sizing boundary
Use Scout up to proof, developer, and lower-load pilot scale. Around 100,000 relationship path records, 250,000 source events a month, high concurrent relationship traversal, or any P95/P99 performance requirement, move the buyer to Fortress or Elite.
JSON task handoff
Assemble schema-validated execution packet 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 path-weight relationship store, private connectors, vaults, identity, and restricted-environment planning.
Back to the platform story
Scout is one part of the KynticAI product family
Design partner program · limited seats
A real program: discounted pilot, founder access, roadmap input — for one hard workflow.
We are looking for a small set of partners who need AI that behaves on enterprise data without giving that data away. You get clear commercial preference, direct time with Paul, and a path to a co-branded case study. We get production-shaped feedback on Scout, Fortress, and Elite.
Seats
Limited
Pilot window
60–90 days
Your time
2–4 hrs / month
Pricing
Typically 40–50% off
Preferential pilot pricing
Typically 40–50% below standard commercial rates on discovery and the first Fortress pilot scope, locked for the agreed pilot window (usually 60–90 days).
Direct founder access
Working sessions with Paul on architecture, data boundary, and pilot success criteria — not a hand-off to a scripted sales process.
Roadmap influence
Your workflow helps set connector order, packet shape, and the Scout → Fortress path so the product fits how you actually buy and deploy.
Co-branded case study path
Where both sides agree, we publish a privacy-safe outcome story your industry peers can trust.
Who this is for
- You help decide how data, AI, or integrations land in the business.
- You have one workflow where a better next task would matter this quarter.
- You can approve a narrow, read-scoped source for a pilot.
- You want data to stay under your control, not shipped into a black-box SaaS by default.
How the program works
- 1
Apply
Tell us the workflow, systems, and what good looks like in 60–90 days. Leave secrets and raw data out of the form.
- 2
20-min discussion
We map Scout → Fortress → Elite to your constraints and confirm seat fit.
- 3
Scope + terms
We lock data boundary, acceptance checks, pilot window, preferential pricing, and feedback rhythm.