Predicting the moment each individual is ready to act — fusing a brand's own data with 0-party signal from the device — at the scale of hundreds of millions of customers.
The same engine reads three very different lives. Each one is forming a moment of need in their behaviour, weeks before they go looking, and weeks before they tell a single brand.
Amara is about to move house. She hasn't told a single brand, and may not have fully decided herself. Intent AI sees it forming weeks early, and surfaces the moment to offer broadband, a family plan and the right financing, before she goes looking.
Daniel already banks with you — a business account, two years in. Now the business is scaling: first hires on payroll, suppliers abroad, card volume climbing, a cash-flow gap opening. Intent AI reads the growth weeks early and surfaces the moment to upsell — lending, FX, payroll and a business card — before he shops around. One account becomes the whole relationship.
Leah is drifting away, and the brand can't see it yet, a loyal weekly shopper now quietly slowing down. Intent AI catches it while there's still time to act, with a reward or a reason to stay, before she defaults to a competitor. A proactive win-back beats a discount sent after she's gone.
Consumers now ask an AI agent to find the best mortgage, the best broadband, the best deal, and the brand never gets a look in. Human context surfaces the moment of need before the consumer turns to AI, giving brands the chance to act first.
A person's life is a string of events laid out on one axis — time. Each event is a single token built from four dimensions — when, where, what (the brand they touched) and who — and each dimension is two layers: the 1st-party data a brand already holds, and a 0-party layer from Intent's on-device SDK, signal the brand could get no other way. Topics and interests aren't a channel; they're read off the brand. Time is the spine, tokens are the words, sequences are the sentences — read them in order and the next move becomes predictable.
One weekend in Amara's data — tap any event to load it into the token above.
One month in Daniel's data — tap any event to load it into the token above.
One week in Leah's data — tap any event to load it into the token above.
The sequence is the moat. Read in order, the next event is predicted and checked against what actually happened — provable, not a guess. A few integers per prediction, not millions of tokens; the patterns learned across trillions of tokens are the edge, not the data.
One event is evidence; a sequence is behaviour. Put enough of it together and a whole individual comes into view — not a segment, a person; in How, this same picture is the world model's view of one life. Here is Amara, and the parts of her life Intent AI reads, all pointing to the one moment a business can act on.
Weekend hours drifting toward a new neighbourhood; commute-route lookups.
Property portals, mortgage rates, school catchments, broadband.
Growing family, long tenure, high value, financially active.
The pre-move sequence: listings, then financing, then home services.
Micro: browse listings. Macro: buy a home. Long-term: settle the family.
About to set up a new home: broadband, a family plan, financing, insurance.
Every part of this traces back to events that actually happened, which is why the moment of need is a prediction you can check, not a story you tell.
For each individual, at a moment in time, Intent AI predicts both the likelihood of reaching a moment of need and the lift from acting on it. The second is where the value lives. Predicting who acts anyway earns little; predicting whom an action moves is the whole point.
Detected weeks before Amara lists or applies. A home move is the trigger for a chain of needs: broadband, a family plan, financing, insurance.
A lookalike in her segment moves only +5 points. Act on the individual at her moment of need, not the average. Persuadability, not raw propensity, is the north star. In How, this number is the simulator's read — the lift it predicts before a penny is spent.
Together they define an opportunity: a specific person, at a specific moment, where acting actually changes the outcome. The opportunity — not the segment — is the unit a campaign acts on.
Predicting the opportunity is only half of it — someone has to act, fast, while the moment is open. Consumers already have AI agents acting for them; the answer for brands is an agentic layer of their own. You set the goal; Intent surfaces the opportunities, simulates the options, and acts — then the response flows back and sharpens the next call.
Tell Intent the outcome — grow broadband, win back lapsers, deepen the relationship. No audience-building, no rules to hand-write.
Every individual at a real moment of need, ranked by persuadability. Opportunities, not segments — the unit you act on.
Campaign agents rehearse each option in simulation and act only on the ones that move people — inside your guardrails.
Goal in, opportunities out, action taken, response learned. One closed loop — and in How, it is the same loop the architecture runs end to end: data, cognition, agency, and back to data.
A prediction only counts if it produces value, costs little to make, and can be proven right. Most platforms win one and lose the others. The discipline is holding all three.
Measured as lift over a hold-out control group. Proven at 15 to 34× across the portfolio.
The lowest-cost inferencing in the category, driven by a global pattern library that means we never relearn the world.
Validated against held-out reality. A prediction you can't check is an opinion, not an asset.
For telco and financial services, the only platform handling this at agentic scale without hallucinating. Partners include Verizon, MTN and Grab.
A 0-party signal the brand can't get any other way. Intent's Edge SDK enriches every channel of every event — sharpening rich first-party data, and standing in where it's thin. Privacy built in; the same SDK deploys across verticals — cyber, insurance, health, identity.
Confidence, provenance and safety on every prediction before it leaves. Agentic scale, without hallucination.
Write once, read millions. Knowledge learned once is reused across every profile, driving accuracy up and inference cost far below the alternatives.
Stated honestly: models are client-scoped and we do not own the underlying customer data. The moat is the architecture, the methodology and the governed universal knowledge, not a single cross-client brain.
Tokenise every behavioural moment. Lay the tokens on a time axis. Learn the sequence at scale, self-supervised. Predict the next move. Simulate every move; act only when it causally matters.
A behavioural token is one moment in a person's life, reduced to a few integers. Four dimensions define it: when (time), where (place), what (the brand they touched) and who (the user). Each of those four is built in two layers: the 1st-party data our customers already have, and a 0-party enrichment layer brought in by Intent's Edge SDK from the user's device — signal the brand could not get any other way. Time is also the spine: every token sits at a point on a timeline, and the model learns by reading those points in order.
1P: timestamp, day-of-week, session start. 0P · SDK: dwell, inter-event intervals, on-device rhythm.
1P: postal area, billing region, channel. 0P · SDK: precise geo, vicinity, type-of-place.
1P: brand touched, product, campaign. 0P · SDK: app, screen, surrounding category exposure.
1P: tenure, plan, value, products held. 0P · SDK: on-device rhythm, habits, companion brands.
Every channel of the token is built in two layers: 1P data the customer gives us, and a 0P layer from Intent's Edge SDK on the user's device. The SDK does not sit alongside the four channels as a fifth signal — it sits across them, contributing consented, first-person evidence to when, where, what and who, to whatever extent the brand's own data leaves unsaid. That second layer is data the brand could not obtain any other way.
SDK signal sharpens what's already there — device rhythm, real-world location and dwell, screen context the CRM never sees.
SDK signal stands in for the channels themselves — 0-party identity, place, time and intent from the device, so the model can perceive a user the brand barely knows.
Time is the spine. Four dimensions make the token. Each is a stack of 1P + 0P. The brand's first-party data lays the foundation; Intent's Edge SDK supplies the 0-party signal that would otherwise be missing. The model learns by reading those tokens in order, one slice of life at a time.
Time is what makes this work. Concatenate tokens chronologically and a day, a week, a life unfolds as a single sequence. The model learns to read it like a language — Sleep, Instagram, Trainline, IntentHQ, Pret — because a life, like a sentence, has an order. Strip out the time order and you have a bag of moments with no meaning; keep it and you can predict the next move before it happens.
Same sequence, two futures. The world model doesn't just predict what's likely — it answers what would change if a brand acted right now. That's the difference between targeting and incrementality.
We never need a label — time supplies the supervision. At each point on the timeline the model sees the past and is asked to predict the next behavioural token. A causal mask enforces the arrow of time: the model can only attend to what has already happened — no leakage from the future. Run this across hundreds of millions of timelines and the model learns how lives actually unfold, moment by moment.
Cross-entropy on the next behavioural token. The same objective that powers language models, applied to the language of behaviour.
No human labels. Every observed sequence supervises itself — the future of the sequence is its own target. Data scales without annotation cost.
From trillions of tokens, the model internalises routines, rhythms, life-stages, and the conditions that change them.
Following LeCun's autonomous-intelligence blueprint, we lift the architecture out of robotics and onto the person. Heterogeneous signals — edge, web, CRM — collapse into a single latent state s[t], but the load-bearing word is t: the state is a slice of a continuously evolving user. The predictor rolls it forward — s[t+1] = Pred(s[t], a[t], z) — emitting a prior distribution over the next behavioural token. The actor — our simulator — takes that prior together with a candidate action and emits the outcome distribution under that action. The cost module — taught by Causal AI — scores it. Every box in the diagram below is anchored to a point on the time axis at the top.
One encoder per modality — edge, web, CRM. They discard the noise (the exact URL, the precise ms) and keep what is predictive of intent.
One hierarchical representation per user. Lower levels for short-horizon prediction, higher levels for life-stage and LTV.
Streaming-updated profile vectors. Only what an event changes is touched — designed for billions of events a day.
Rolls the state forward: s[t+1] = Pred(s[t], a[t], z). A latent z captures the irreducible uncertainty of human behaviour.
Immutable guardrails (privacy, frequency caps, fairness), a trained critic that scores long-term LTV and retention, and a Causal AI teacher term that distils CATE-uplift from past randomised holdouts directly into the cost signal driving the actor.
Searches the space of content × channel × timing × offer, simulates each through the world model, picks the action that minimises expected future cost.
A propensity score answers "is this person likely to act?" — a question every competitor can answer. The simulator answers a harder one: "would this person act differently because of what we did?" The simulator is, concretely, a learned function that takes the world model's prior distribution and a candidate action, and emits the outcome distribution under that action.
The world model simulates both worlds — "no action" and "this action" — and compares the predicted trajectories. The gap is the causal uplift, the only quantity that matters for ROI.
Trained with X-learner, DR-learner, causal forests and meta-learners on randomised holdouts and natural experiments. Per-individual treatment effect, not population averages.
Separates the propensity (would they have acted?) from the outcome (did the action change anything?). Robust to confounders the encoders couldn't fully strip.
A small, governed slice of impressions is randomised. That slice is the only ground truth for causality; everything else is observational and biased by the logging policy.
Causal AI sorts each individual into one of four cells. Only one is a real opportunity — and it is the only cell that deserves an impression. This is how we drive the cost of action down and the impact up.
Won't act on their own, will act if nudged. This cell is the opportunity — the only group where impressions create value, and where the simulator spends.
Going to act anyway. An impression here is wasted — worse, it pollutes attribution and earns false credit.
Won't act regardless. The simulator saves the impression and the frequency-cap headroom for someone else.
Would act on their own but will react badly to contact. Targeting them destroys value. The simulator suppresses contact.
Thousands of controlled experiments. The only data where causality — not correlation — can be measured directly.
X-learner, DR-learner, causal forests, double ML. Estimates the per-individual treatment effect that defines "what would actually change?"
f(Pprior, action) → Poutcome. Scored against the teacher's uplift labels through the cost function, so the emitted Poutcome matches what would actually happen under that action.
Causal AI learns the truth slowly and expensively in controlled experiments. The simulator learns the truth quickly and cheaply by being taught — its loss is the teacher's CATE signal, baked into the world model's cost function. The result: causal decisions, at the speed of self-supervised serving.
One unified loss for the world model and the simulator. Self-supervised next-token prediction trains the world model on the firehose. Causal AI acts as the teacher — its CATE-uplift estimates, learned from past randomised holdouts, become a supervised label that flows directly into the cost function and tells the simulator "did this action actually move the needle?". The immutable guardrail term sits inside the same cost so the actor cannot optimise it away.
The simulator's job is not to predict who acts — it is to predict whom an action changes. Causal AI is how the simulator earns the right to spend an impression, and how every action is rehearsed in simulation before it's served.
Behaviour rolls forward like a language. The world model takes the sequence so far and emits a probability over the next behavioural token — pick the top, append, repeat. The simulator then asks the harder question: given everything we've learned from past randomised holdouts, which action would shift that distribution most?
The model emits a distribution over the next behavioural token. The argmax is selected, appended to the sequence, and becomes the next input. Generation rolls forward — exactly like an LLM, except the language is life.
Same prior, four candidate actions, four predicted outcome distributions. The uplift on the target outcome is the simulator's score for each action. Only the action with positive, significant uplift earns the impression.
The world model says what's likely. The simulator says what's worth doing. The first is autoregressive prediction; the second is causal inference grounded in every randomised holdout we've ever run.
Five stages, one closed loop, one shared axis: time. Raw behaviour is tokenised into behavioural tokens, per-modality encoders fuse the streams into a single time-ordered sequence over one vocabulary, a sequence model learns the patterns the way it would learn a language — by reading them in order — a causal-AI-distilled simulator scores what happens if we act, and every controlled market test feeds back into the next training pass. Behaviour evolves along the time axis; the model is trained to evolve with it.
Before any model can read it, raw behaviour has to be made discrete. A per-modality tokeniser turns every behavioural moment — a page view, a CRM event, an edge ping, a market signal — into a behavioural token. One vocabulary per modality; the same language for every downstream stage.
Tok_web · Tok_crm · Tok_edge · Tok_mktTo perceive the user's context, each token stream goes through its own encoder. Every encoder projects its modality's tokens into the shared latent space. The streams then interleave by time into a single behavioural sequence over one shared vocabulary — the substrate the world model actually learns from.
Shared vocab · time-ordered · multi-sourceA seq2seq model learns the patterns in those latent sequences. Trained self-supervised with a next behavioural token prediction objective — no labels, just the firehose. Its output is the prior probability over what the user is likely to do next.
Self-supervised · next-tokenAn intervention model — the actor / controller / simulator — takes the prior probabilities together with a candidate action and produces the probabilities if that intervention were applied. Trained by distillation from a causal-AI teacher: counterfactual reasoning, baked into a fast model.
Causal-AI teacher · distillationThe simulator surfaces an opportunity worth pursuing in the market. A controlled-group test gives the ground truth, and the result feeds back to reinforce learning. Every loop tightens the model — the path by which we get to the world model we envision.
Controlled test · reinforce · world modelHow well does the world model predict the next behavioural token on held-out sequences? The primary loss, the cleanest signal of perception + prediction working together.
How well does the simulator rank persuadables above sure-things and sleeping dogs? Measured against the causal-AI teacher and against randomised holdouts — not the logging policy.
The final word, and the signal that closes the loop. Long-horizon outcomes against a strong baseline — slow, expensive, the only one that counts, the one that feeds the next training pass.
Stated honestly: the causal-AI teacher is itself an approximation, and distillation inherits its biases. We treat the simulator with humility — used for relative ranking of interventions, continuously recalibrated by the closed-loop market tests above. Guardrails are immutable so the actor can't optimise them away.
Stepping back from the model and asking what the product looks like — it's three layers stacked on top of each other, with a closed loop running through all of them. A Data Layer moves brand data in and out. A Cognitive Layer turns it into a continuously-learning behavioural world model. An Agentic Layer is the new UX — opportunity intelligence and autonomous marketing — that lets users drive outcomes through goals and preferences. Each layer consumes from the one below it; the top layer acts on the world; the world's response flows back to the bottom and closes the loop.
Connectors and integrations for both inbound (brand data flowing in — web logs, CRM, edge, market) and outbound (activation flowing out, plus the responses the world sends back). The plumbing that makes everything else possible.
This is where the model continuously learns from the data and from the world. Tokenisers, encoders, the seq2seq world model, the simulator — and the profile enrichment that turns raw signal into a usable user-state.
The user-facing layer. A new UX moving teams towards opportunity intelligence and autonomous marketing excellence, driven by the user's goals and preferences. Deep agentic enablement — users tell us the outcome; agents propose, simulate and act on it.
Data feeds cognition. Cognition feeds agency. Agency acts on the world. The world responds. The response feeds data. One loop, three layers — the product is the shape that loop takes.
The roadmap builds the three-layer product described in How: a Data Layer for connectors in and out, a Cognitive Layer where the behavioural world model continuously learns, and IntentOne — the product surface where every capability reaches users, through agents and applications. v1 is a telco pilot: prove the closed loop end-to-end with the data a telco already has — web logs, CRM, and time. Every span ships a commercial capability; the loop closes with a controlled-group test.
Every workstream below maps directly to a piece of the architecture in How. The Data Layer is one workstream. The Cognitive Layer is five — Knowledge Base & Vocab, Encoders, Edge Signal Discovery, Predictor, Simulator. IntentOne — agents and applications — is one. Each is delivered end-to-end (planned · built · evaluated · integrated) and ships a commercial capability when it lands.
Inbound connectors for web, CRM, edge and market data; outbound activation channels; identity, consent and the response-capture path that closes the loop back into the system.
Reference data — brands · topics · interests · intents — plus the behavioural tokeniser that turns raw signal into discrete tokens. The shared vocabulary every downstream model uses.
Per-modality encoders — Enc_web · Enc_crm · Enc_time first (telco v1) — fuse modalities into one time-ordered behavioural sequence over the shared vocab. v2 widens to market, finance, retail.
Intent's SDK mines consented, first-person signal that enriches all four channels of the token — when, where, what, who. Sits across the channels, not as a fifth.
Self-supervised, next-token, causally masked — time supplies the supervision. Reads the unified sequence the encoders write and emits a prior over what the user does next.
Distilled from a Causal AI teacher (DR-learner · CATE). Takes the prior + a candidate action, emits P(outcome | do(a)). A controlled-group loop closes onto the world model.
Agents are how users interact with Intent AI — insights, simulations, optimisations: opportunity intelligence agents that surface what to do, campaign agents that compose and run it. The applications they live in, plus the guardrails for oversight, are what make every capability below actually usable. If it isn't surfaced in IntentOne, it can't be used.
Evaluation runs through every workstream above — behaviour tokeniser, every encoder, reference data (brands · topics · interests · marketing contact responses), the predictor, the simulator. The test is built before the model is trusted.
Monetisation leads delivery. The first commercial milestone is a paid telco POC signed in September — sold on today's engine and the evaluation proof, ahead of the new capabilities. Each capability then upgrades what's already sold: when the telco encoders land, agents query the encoded space (latent + boolean filters); when the predictor lands, that becomes behavioural-semantic querying; when the simulator lands, every campaign carries a per-user uplift score. Revenue starts early and compounds.
Seven swim lanes spanning the three product layers — Data Layer (connectors), Cognitive Layer (KB & vocab, encoders, edge signal discovery, predictor, simulator) and IntentOne (agents + applications) — run from Jul 2026 through Jun 2027. Each lane is delivered end-to-end: planned, built, evaluated and integrated into the product before the next span starts. Every completed span ships a capability (★ on the chart) — something we can sell. The bottom lane is the commercial path (◆ revenue milestones); the first lands in September, ahead of the build, so monetisation leads delivery and compounds as the stack matures.
Every swim lane below is delivered end-to-end: features are planned, built, evaluated, and integrated into the product. No half-shipped capabilities — when a span finishes, what comes out is sellable. Reading the chart: ★ = a capability shipped ("Cap" — a span finished, evaluated and integrated, something we can sell); ◆ on the bottom lane = a commercial milestone, an actual revenue event.
The Data Layer is the foundation — not a numbered capability, but the plumbing the seven build on. Inbound connectors, identity & consent, outbound activation, response capture. Once it's live, brand data flows in and out end-to-end.
Unified brands · topics · interests · intents + behavioural tokeniser. Agents and product teams query a clean reference base — the shared vocabulary every downstream encoder, predictor and simulator reads from.
With the telco encoders shipped — Enc_web · Enc_crm · Enc_time producing one unified time-ordered sequence — agents move beyond boolean filters. They can now slice and dice via behavioural semantics over the latent space (“users whose web/CRM/time pattern looks like X”), before the predictor or simulator is even live.
Once the edge signal encoder is added, the same semantic querying extends to on-device, 0-party signal — agents can find audiences from real-world rhythm, dwell and location context.
With the seq2seq predictor live, the product can predict what a customer is most likely to do next — revealing short-, mid- and long-term intents and moments. Critically, unlike the v1 implementation, this is an optimisation loop we control: dramatically lower inference cost and far easier to evaluate.
The intervention model — taught by the Causal AI teacher (DR-learner, CATE) — can play out how each user would respond to a marketing campaign and pick the best offer given that user's state and context. Uplift, not just likelihood. The judgement layer of the Cognitive Layer.
Continuous SDK-sourced signals — what they like, where they visited, when something happened, who they are, and what led to a specific event — flow into every channel of the token (when · where · what · who). Critical to the vision: the 0-party layer everything else gets richer on.
IntentOne is the product surface where every capability gets used — agents and applications. Agents are how users interact with Intent AI (insights, simulations, optimisations): opportunity intelligence and campaign agents. Plus the applications they live in and the guardrails for oversight. If a capability isn't surfaced through IntentOne, it can't be used.
Commercial path (◆). Monetisation does not wait for the full stack. September: a paid telco POC, sold on today's engine plus the evaluation proof. December: first new-model commercial close on the opportunity / semantic-query SKU (rides the Data Layer + reference knowledge + telco encoders). Q1 2027: outcome-based, uplift-share pricing once the simulator's controlled-group read is credible. Mid-2027: the agentic UX and the first sector pack (finance / retail). Capabilities ship the product; commercial milestones bank the revenue — and they lead the build.
Indicative timeline · current thinking. These dates reflect how we're sequencing the work today. We expect to refine and update them as we move into execution — discoveries in one span shift the next, and evaluation is the gate on every transition.
A behavioural token is only as rich as the encoders behind it. v1 is scoped to the data a telco pilot already has: web logs, CRM, and time — the shared temporal axis that anchors every other modality. That's the smallest set that closes the loop end-to-end. The wider vocabulary — edge, market, finance, retail — is held for v2, once v1's controlled-group test has shown real uplift.
The minimum vocabulary that lets us tokenise telco behaviour, train the sequence model, run the simulator and close a controlled-group test on real users.
Brands and topics from search and browse — the highest-frequency consumer–brand signal a telco has.
Web · telcoThe shared temporal axis used by every other encoder — clock, day-of-week, dwell, recency, inter-event intervals. Consistent across modalities.
Cross-modalityTelco profile — tenure, plan, products, value. Who the user already is to the operator.
Profile · telcoEach v2 encoder either deepens the token or opens a new sector. We add them in order of data-flow and consumer–brand interaction frequency — but only after v1 closes the loop.
On-device signals from Intent's SDK — rhythm, motion, location, app context. The 0-party enrichment layer.
Device · cross-sectorExternal context — trends, prices, news, the broader pull on a person at the moment.
Market · cross-sectorTransaction data — what people actually pay for, not just what they browse.
Finance sectorShopping and purchase data — baskets, loyalty and store behaviour.
Retail sectorv1 is small on purpose. Web + CRM + time is the smallest vocabulary that lets us prove the whole loop on a telco pilot. Everything else — the edge layer, the sector encoders — is held until v1 has earned the next step.
Today each prediction is an inference call over a person's brands and interests — accurate enough, but costly and hard to test. The roadmap replaces it with the seq2seq world model from How: per-modality encoders fuse into one time-ordered behavioural sequence over a shared vocabulary, and the predictor learns P(next | history, context) by next-token prediction — self-supervised, causally masked. The human context model is a stack of layers, and the keystone is the sequence.
Sequences is the pivot. It is the capability not yet built, and the one every layer above depends on — which is why it sits first on the build, ahead of the deeper encoders.
Predicting the moment is half the job; knowing whether acting changes anything is the other half. The intervention model from How — the actor / controller / simulator — takes the predictor's prior together with a candidate action a and emits P(outcome | do(a)). It is distilled from a Causal AI teacher (DR-learner · CATE) and continuously recalibrated by a controlled-group loop. Commercial actions enter the sequence as tokens, so the simulator learns not just what happens next, but what would happen if a brand acted now.
A held-out control against a treated group — the only clean read on cause, not correlation. Feeds the closed-loop reinforcement.
DR-learner / CATE estimators teach the intervention model what counterfactuals look like, so inference stays cheap while keeping causal grounding.
P(y|do(a)) − P(y). Per-person propensity at the moment, plus the ROI of acting. Together, the opportunity worth spending on.
This is the intervention model the How tab puts to work. The Causal AI teacher + control-group loop is how it earns its judgement — turning a predicted moment into a scored, provable opportunity.
Evaluation isn't a phase at the end — it runs through every workstream above: the behaviour tokeniser, every encoder, the unified sequence, the predictor, the simulator, the SDK signal discovery, and the agentic layer. The same person who builds the piece builds the test that proves it. Reference data — brands, topics, interests, marketing-contact responses — is the line in the sand we measure everything against.
Every metric works on two levels: does the prediction match held-out reality, and does acting on it produce real uplift against a control group. Without a shared yardstick, two approaches can't be compared — like marking two exams without knowing they sat the same paper.
Next-token and per-layer accuracy on behaviour the model hasn't seen. Baseline first, then measured, incremental gains.
Measured against a hold-out group. A prediction that doesn't move a real number is an opinion, not an asset.
Single-profile consistency and automated plausibility scoring across thousands of profiles — so the full picture coheres, not just the average.
Bottom layer first, then up: Data Layer so brand data can flow. Then the Cognitive Layer piece by piece — knowledge base & tokeniser, the telco v1 encoders, the unified sequence, the seq2seq predictor, the intervention model. Then IntentOne — agents and applications — on top. The Edge SDK signal discovery runs alongside the cognitive work. Evaluation runs through every step.
Connectors in & out, identity / consent. Build the KB + behavioural tokeniser so everything else has a vocab to share.
Enc_web · Enc_crm · Enc_time producing the unified time-ordered sequence. Agents query latent + boolean before the predictor is even live.
The seq2seq world model, then the intervention model distilled from the Causal AI teacher. Closed-loop control-group test on the way.
Agents and applications — opportunity intelligence and campaign agents, the UX they live in, guardrails. Everything below gets used through IntentOne.
Stated honestly: the seq2seq predictor and the intervention model are not yet built — today's production engine runs per-event inference on live telco data. The roadmap is the move from that to the three-layer product in How, earned one proven span at a time. Capability ships at the end of every span.
The execution view of the roadmap: two enrichment tracks — Weblogs and SDK — converging on the behavioural-token layer. Milestone 0 lands next week, milestone 1 closes inside this window, milestone 2 starts, milestone 3 is earned later. Every deliverable ships standalone value into IntentOne on the way, and the whole plan is live in Linear under the Intelligence (IntentAI) initiative ↗.
Internal stakeholders asked for one thing: brands, topics and interests they can trust. So each track earns its way down the page: publish the truth (milestone 0, next week), fix the signal and prove the improvement in the product (milestone 1), encode it (milestone 2), model it (milestone 3). No milestone closes on analysis alone — each one is something a stakeholder can see.
NSFW and machine/adtech activity filtered before enrichment. The fight is the inversion: ~97% precision/recall on non-user activity vs ~15% on user activity today.
Attribution corrected — credit the brand visited, not the ad call underneath. Measured, explainable uplift vs the baseline for MTN Nigeria and Verizon.
Today SDK signal feeds nothing into brands, topics & interests. Structure it into the four boxes — when / what / who / where (+ duration) — per time-step, from Alexander’s framing, with the new hire pairing from day one.
The Vivo and Fishka proof, at agreed SDK-only thresholds (~70% of full context), with behavioural patterns — “this person is a runner” — where brand affinity isn’t the natural frame.
Cleaned signal from both tracks encoded per time-step over the shared vocabulary — the tokeniser the How tab depends on. The unproven leg of the stool (done before / infrastructure / skills): highest research risk, highest moat — which is why it starts only after milestone 1 has shipped standalone value.
The seq2seq world model trained on behavioural tokens, validated predictively against the MTN workstream (pre→post migration, prepay churn, MoMo churn) with client-data-only baselines as the honest comparison.
M1 has the SDK track on its critical path. If Alexander’s allocation isn’t confirmed, the fallback is M1 closing on weblogs-in-product with SDK following — the degraded case, not the plan. The four decisions that keep this plan whole: M1 scope (brands, topics & interests only, segments & moments deferred to M2+, not dropped), Tobie’s technical leadership of the pipeline handover, Alexander’s allocation, and the two open hires.
Already started work in the sequencing space; will benefit from adding SDK experience.
A Cambridge Computer Science MSc intern and an IntentAI PM arrive to accelerate the work here.
Two roles open to keep the plan’s dates honest.
IC here, and only here. He makes design decisions for data ingestion, but no IC work is scoped there — which may mean leaning more on Tobie.
Where to follow it: the plan is tracked in Linear — the Intelligence (IntentAI) initiative — with a project per deliverable (linked above), milestones on each, and the PRD attached to the initiative. Dates are indicative: evaluation gates every transition.