KK.
EN CS
Book a call

Services

The strategy and the build, scoped as fixed packages

Project-based, remote or hybrid. Fixed fee or time-and-materials: decided at the intro call, never before.

What I build

Five things, in depth

Which one you need is usually part of the conversation, and often it is not the one you came in for.

RAG & assistants

Answer questions over your own content and data, with citations, so people stop guessing and stop pasting into a chatbot with no guardrails.

When it's the right call

  • Your answers live in documents, a catalog, or tickets, and staleness matters.

When it isn't

  • The answer is a single number from a database: that's a query, not RAG.
  • The corpus is tiny enough to paste into a prompt.

What I deliver

  • A retrieval pipeline grounded in your sources
  • Citations and guardrails
  • An eval set and a pass/fail bar before it ships
  • A plan for keeping the index fresh

Typical stack: Python, a vector store, an embedding model, an eval framework, tracing.

eval set: retrieval
query                        expected source        hit   ndcg@5
"return window for boots"     policy/returns.md       yes   0.91
"is the X1 pump in stock?"    -- (needs live data)    no    0.00
"how do I reset the meter?"   kb/meter-reset.md       yes   0.88

Chatbots

Conversational front-ends done properly: scoped, evaluated, safe. Not a widget bolted onto the corner of the site.

When it's the right call

  • A bounded domain, a clear hand-off to humans, and you'll measure whether it actually helps.

When it isn't

  • "A bot that can answer anything."
  • Nobody owns the eval.

What I deliver

  • A scoped conversation design
  • A safe hand-off to a person
  • Multilingual where it matters
  • Measured on resolution, not deflection alone

Typical stack: an LLM API or a small model, a conversation framework, an eval harness, tracing.

Agents & workflow automation

Multi-step systems that call tools and take actions, with guardrails and a human in the loop where the stakes are real.

When it's the right call

  • A repeatable multi-step task with clear inputs and a reversible or approvable output.

When it isn't

  • An irreversible action with no review.
  • A task a plain script would do better.

What I deliver

  • The agent and its tools
  • Approval gates where they belong
  • Observable, reversible steps
  • An eval on the end-to-end task

Typical stack: an agent framework, your existing APIs, a queue, tracing, an eval harness.

Classic ML

Recommenders, scoring, forecasting, segmentation: for when an LLM is the wrong tool and a model is the right one.

When it's the right call

  • You have labelled outcomes or a clear signal, and latency, cost or interpretability rule an LLM out.

When it isn't

  • No data yet.
  • The problem is genuinely language.

What I deliver

  • A baseline model
  • Offline metrics and an online A/B or sanity checks
  • A retraining plan so it doesn't rot
  • An honest read on whether the data supports it

Typical stack: Python, the usual ML libraries, a feature store or a simple pipeline, an experimentation setup.

AI observability & evals

Know whether your AI is any good, and catch it the day it regresses: the sharpest place to start if you have already shipped something.

When it's the right call

  • You have an LLM feature in production and you don't fully trust it.

When it isn't

  • Nothing is shipped yet: start with the build.

What I deliver

  • Eval sets and eval-in-CI
  • Trace-level logging, cost and latency
  • Regression alerts
  • Guardrails for PII and prompt injection, and an A/B setup

Typical stack: a tracing/eval platform, CI, dashboards, guardrail middleware.

trace
{ "span": "retrieve",  "ms": 42,   "k": 8, "hit": true }
{ "span": "rerank",    "ms": 88,   "kept": 4 }
{ "span": "generate",  "ms": 1240, "tokens": 512, "cost_usd": 0.0031 }
{ "span": "guardrail", "ms": 6,    "pii": false, "flagged": false }

How it works

Scoping an engagement

The shape of a typical engagement: an intro call, a short discovery, a build, then an optional hand-off to a fractional lead.

  1. Intro call (30 min)

    Your situation, your data, and whether this is even the right problem.

  2. Discovery & solution design (1–3 wks)

    2–3 candidate use cases ranked by impact and effort; the approach decision; success metrics; an architecture.

  3. Build & prototype (4–8 wks)

    A working prototype, integrated. Baseline evaluation. Documentation and a roadmap. A handover.

  4. (Optional) Fractional AI Lead

    Ongoing part-time ownership: roadmap, reviews, keeping the evals honest, mentoring the team.

Packages

Four ways to start

Fixed scope, fixed fee: quoted after the intro call, never before.

AI Discovery Sprint

For Teams unsure where AI actually pays off.

Duration 1–3 weeks

Scope

  • Your situation, your data, your constraints: reviewed
  • 2–3 candidate use cases, ranked by impact and effort
  • Approach decision per case (LLM API vs a model, RAG vs a recommender, build vs buy)
  • Success metrics defined up front
  • A one-page architecture sketch

You get

  • A prioritised use-case shortlist
  • An approach recommendation with the reasoning
  • Success metrics and an effort/impact estimate
  • The architecture sketch

Outcome You know which AI work to do first, why, and what 'good' looks like.

Fixed fee, quoted after the intro call.

Book the intro call

Prototype Build

For A chosen use case that needs to exist and be measured.

Duration 4–8 weeks

Scope

  • A working prototype, integrated with your systems
  • A baseline evaluation: offline metrics, an A/B or sanity checks
  • Documentation and a next-steps roadmap
  • A handover to your team

You get

  • The integrated prototype
  • The evaluation and its numbers
  • Docs + roadmap
  • A working session to hand it over

Outcome One AI feature in front of real users, with numbers you trust and a team that can run it.

Fixed fee, quoted after the intro call.

Book the intro call

Audit & Fix

For An existing RecSys / ML / LLM feature that underperforms or isn't trusted.

Duration Scoped per case

Scope

  • An audit of the metrics, the data, and the architecture
  • A quick-wins list
  • An eval harness so regressions get caught
  • An improvement roadmap with estimated impact
  • For e-shops: an EU AI Act readiness pass (help, not legal advice)

You get

  • The audit findings
  • The quick-wins list
  • The eval harness
  • The roadmap

Outcome You know why it underperforms, what to fix first, and how you'll know it improved.

Fixed fee, quoted after the intro call.

Book the intro call

Fractional AI Lead

For Teams shipping AI without senior AI ownership.

Duration Monthly retainer, min. 3 months

Scope

  • Roadmap ownership
  • Architecture and PR review
  • Eval governance: keeping the numbers honest
  • Vendor and model decisions
  • Mentoring the team

You get

  • A maintained roadmap
  • Regular reviews
  • Eval and cost/latency oversight
  • A team that levels up

Outcome Senior AI judgement in the room every week, without a full-time hire.

Monthly retainer, min. 3 months: quoted after the intro call.

Book the intro call

Honesty

What I don't do

  • No data-labelling shop.
  • No "just prompt engineering" retainers.
  • No rescue of an abandoned project without a rebuild.
  • I'm not a legal advisor: AI Act help is help, not legal advice.

FAQ

Common questions

Can the scope change once we've started?

Yes, within reason. The package fixes the shape, not every detail: small adjustments are normal; a materially different problem is a new conversation and usually a new quote.

Who owns the code and the IP?

You do. Everything I build for you is yours: code, prompts, eval sets, docs. I keep nothing proprietary in the deliverable.

Which models and tools do you use?

Whatever fits the problem, chosen at discovery: not a fixed stack. I stay vendor-neutral: the approach decision (LLM API vs a model, which provider, RAG vs a recommender) is part of the work, not a given.

Do you work remotely?

Yes: remote by default, hybrid if you're in the EU and it helps. I've run production systems with distributed teams for years.

How do you handle our data?

Minimally and on your terms. I work in your environment where possible, don't move data I don't need, and the privacy note on the contact page covers the form. Specifics (access, retention, sub-processors) are agreed before any work starts.

What's a typical timeline?

One to three weeks for discovery, four to eight for a prototype. Audits are scoped per case. A fractional retainer is monthly, minimum three months.

What do you need from us to start?

A real problem, access to the relevant data, and someone on your side who can make decisions. Most AI failures are data and architecture failures, not model failures, so the honest read on your data comes first.

Will you sign an NDA?

Yes. Send yours, or I have a short mutual one.

Not sure which one you need?

That's the intro call: thirty minutes, no pitch.

Book a 30-min call