I help companies use AI where it actually improves the work
SEE PROJECTS →AI helps when it fits the process, not the other way round.
I focus on four things. Process analysis: interviews, data from the systems, documentation, a map of the steps and of where time is lost. AI deployment in companies: agents built inside the tools people already use, a human in the loop where mistakes are costly, measurement before and after. Building effective AI agents: LangGraph, tools and memory, models chosen by measurement, evaluation, cost control. Redesigning processes with agentic AI: for every step, I decide whether to delete it, automate it with code, hand it to an agent or keep a person on it.
The proof is Trader AI Assistant, a production platform with AI agents that I founded and built from process analysis to sales, and the analysis and automation of a company's accounting process. I also build on-device AI: models that run on a laptop or a phone, without sending data anywhere.
Behind this are fourteen years of commercial software engineering and a master's degree in psychology. Psychology helps where projects usually stall: in interviews about how the work really goes, and in getting people to adopt a new tool.
Trader AI Assistant
Founder · production platform with AI agentsA mentoring platform for traders, on sale since 28 September 2026 (web, iOS, macOS). The AI mentor Milo coaches each user against their own written methodology, while agents prepare the session plan, close the day, build a memory of the trader and write the weekly synthesis. I took it from process analysis through architecture and code to deployment, cost control, quality and sales. Honest about scale: today it proves a full product cycle, not a large user base.
MORE — ARCHITECTURE & COMPETENCIES
- Architecture. Express/TypeScript and PostgreSQL 17 on my own server, migrated off Cloud Run, Supabase and Firebase in two weeks: row-level security per user, a reverse proxy, backups with a restore check. React + TypeScript front end; a Python market-structure engine isolated in a worker thread.
- Agents on LangGraph. Fixed-shape graphs with a human-approval interrupt (the session plan takes effect only after the trader approves it), Milo with a tool loop, and Deep Mentor (project 03). Rule: deterministic code computes results, stops and risk; the model interprets and has no write path to anything that touches money.
- Models chosen by measurement. A model registry for 51 roles, switchable without a deploy. Gemini vs Kimi on 145 test cases ended 137 to 106, with Kimi 10–30× more expensive, so the platform went back to Gemini.
- Quality. About 250 prompt test cases (promptfoo) under the rule “a test must fail before the fix”, traces in Langfuse, recurring mentor audits with a fix backlog, about 600 test files (vitest, Playwright, pytest), CI gates for prompt quality and security.
- Native Apple apps (Swift). An iOS app in TestFlight (SwiftUI, push notifications, on-device dictation), a macOS menu-bar companion, a shared Swift 6 package, PL/EN localization, notarization.
- Product and security. Stripe subscriptions and entitlements, OIDC sign-in with a session handoff to the native apps, SSRF protection, rate limits, GDPR data export; my own MCP server (OAuth 2.1 + PKCE) and a futures broker API with auto-journaling and a live risk-rule guardian.
- Optimization by removal. I cut a feature that cost up to 6 minutes and 14 cents per trade and produced no evidence in 354 cases, and halved the mentor prompt's tokens while improving quality. A shared cost ledger reserves budget before every model call.
Process analysis & AI deployment
Process mapping · delete / code / agent / humanBefore any model, a map. I analyze a process the way a forward deployed engineer does: from three sources (how people really work, data in the systems of record, documentation), with loops, exceptions and an owner for every step. Then each step goes into one of four buckets: delete it, automate it with code, hand it to an agent, or keep a person on it. I have done this for a trader's mentoring process and for a company's monthly accounting close.
MORE — ARCHITECTURE & COMPETENCIES
- Mentoring process map. A trader's day and week as 30 steps in four buckets. The map exposed a duplicated step, a step with no owner, a missing form field and time lost between steps — things no model would have found by itself.
- Company accounting close: analysis and automation. The monthly close as 10 steps (bank statement, foreign and domestic invoices from the national e-invoicing system KSeF, internal documents, costs, reconciliation, VAT return, CIT advances), split between code (rules for 16 vendors, statement-to-cost matching, a final reconciliation check in Python), an AI agent (finding documents, reading PDFs, working in the accounting system through the browser) and a person (sign-ins, approving documents, filing the return). Rule: nothing disappears silently — every unbooked item goes to a human decision.
- Interview toolkit. Questions about the last concrete case and its exceptions rather than “how it usually goes”, waiting time between steps, the cost of a mistake at each step, a KPI baseline before building, and arguments matched to the person who decides.
- Teaching materials. Nine narrated videos with slide decks on deploying AI agents: the deployment engineer's method, the skills it takes, and the AI layer of my own platform (model selection, trust boundaries, agent knowledge, evaluation, optimization, hallucinations).
Deep Mentor
Agent with memory · retrievalThe deep-analysis agent of Trader AI Assistant: a ReAct agent with 10 tools and memory, ported from the Claude Agent SDK to LangGraph. It reads a structured memory of the trader — current focus, evidence-backed hypotheses, corrections — and cites it, instead of answering from general knowledge. Retrieval combines full-text and vector search; measurement raised recall from 23% to 85%.
MORE — ARCHITECTURE & COMPETENCIES
- Memory written by the platform. After each trading day, agent pipelines update the trader's memory; the mentor then cites it in its analyses.
- Hybrid retrieval, measured. pgvector fused with full-text search via Reciprocal Rank Fusion, checked on a set of real questions — recall went from 23% to 85%.
- Cost as a design constraint. Digests in prompts instead of raw dumps, expensive deep runs only on demand, and a model-free memory health guard that checks the memory without spending tokens.
audit-mentor · finding-ledger
LLM quality evaluation · open sourceA harness for recurring audits of the AI mentor's answers: an error taxonomy, findings deduplicated by root cause, occurrence count as priority weight, a fix backlog with code locations and a regression case for every fix. Organizing principle: deterministic code computes the metrics, the model only interprets. The lifecycle behind it is now an open-source Python library, finding-ledger.
MORE — ARCHITECTURE & COMPETENCIES
- Recurring audit of the mentor's production answers. Every finding carries an evidence quote and a root-cause hypothesis — no vague “could be better” notes.
- Regression backlog. Findings are deduplicated by root-cause signature, an occurrence counter sets priority, each entry points to path:line locations, and a golden case is written before the fix.
- finding-ledger, public on GitHub. The same lifecycle showed up on its own in a second system of mine, so I extracted it: root-cause deduplication, regression cases written before the fix, false positives retracted with history instead of deleted. It is the layer that prompt-test runners and observability platforms leave to you. pytest plugin, GitHub Action, MCP server, CI on Python 3.9/3.11/3.13; not yet on PyPI.
I'm Here & Murmur
On-device AI · Swift · iPhone & MacNative apps where the model runs on the device. Murmur for iPhone (Szept in Polish) translates face-to-face conversations: the other person speaks, I hear Polish in my earbuds. Its offline mode runs entirely on the phone and never sends audio anywhere. Murmur for macOS is a separate app that interprets calls through two parallel Gemini Live sessions. I'm Here is a live conversation assistant for the Mac: it transcribes both sides locally and shows short answer cards written by a local model from my own knowledge base.
MORE — ARCHITECTURE & COMPETENCIES
- Murmur for iPhone — two apps. The main app translates English into Polish: Apple's on-device speech recognition or, as a selectable option, NVIDIA's Parakeet v3 on Core ML (CPU and Neural Engine), then Apple Translation and a Polish voice. A travel version covers English, Thai, Vietnamese and Filipino: Whisper large-v3 on Core ML, Apple Translation where it supports the language and a Gemma translation model through llama.cpp where it doesn't. It works both ways: I answer in Polish and the phone speaks my reply in the other language. Model files are pinned and checksum-verified; nothing is downloaded silently when a conversation starts.
- Engineering for the phone. Memory limits and releasing models, thermals, a locked screen through a Live Activity with a Stop button, bounded queues, recovery after an interrupted audio route, and a “listen until I stop it” mode with no idle limit: fifteen minutes of silence during a physiotherapy session is part of the conversation, not its end.
- Hearing in the real world (October 2026). Logs from noisy places — a taxi, a city centre — showed the app wasn't deaf: it couldn't find where sentences ended, so it cut speech at a fixed limit and the model got fragments. I added a small on-device voice detector (Silero VAD) and tested it against the old method on the phone, on identical audio: four languages, quiet speech, noise, hum, pauses, and a real-microphone trial. It recovered very quiet speech that the old method dropped in all four languages and stopped sending pure noise to the model. With the real microphone, though, it lost a noisy sentence with Whisper. That regression is the next test, not a footnote. Noise suppression, separating overlapping voices and a full fifteen-minute locked-screen trial are still ahead. What this taught me →
- Murmur for macOS. Full-duplex interpretation in about 35 languages, audio capture through Core Audio (process and system taps), end-to-end latency tests (p50 about 3 s), a signed and notarized installer. Used in live calls.
- I'm Here. Transcription of both sides on the Mac (Parakeet on MLX), and answer cards from a knowledge base of short cards kept in git: for each question the app finds the few cards that match and a local model on MLX writes the answer from them; a code check flags any number or name that isn't in the cards. I moved from one large knowledge pack held in a warm cache (Gemma 4, first token in about a second) to retrieval, and chose today's model, Qwen, in a blind comparison of three models — some speed traded for fewer wrong answers. It can also speak my translated words in my cloned voice, generated locally.
- Measurement over impressions. Each piece was chosen after tests on the target device, not from documentation: what the phone holds in memory, where latency comes from, which model answers well enough — and when a test shows a regression, it stays in the record.
Scout
Research agent · MCPA market-analysis agent with a hard autonomy boundary: it analyzes, suggests and alerts, but the decision always stays with the human — zero auto-trading, no exceptions. My own MCP server with 38 tools, a FastAPI + React panel, a walk-forward backtesting lab with an experiment journal, historical day replay and about 570 pytest tests.
MORE — ARCHITECTURE & COMPETENCIES
- A market radar that separates roles: deterministic code computes the metrics, a narrative layer from web research adds context — the model never invents the numbers it reasons about.
- “Blind” analyses. The agent produces its analysis without seeing the human's view, and only then are the two compared — a learning loop designed to avoid anchoring.
- Lab: walk-forward backtesting with an append-only experiment journal, replay of historical days, and a decision model running in shadow mode with a canary on a golden set before it is trusted.
Python trading system
Async Python · case studyA production asynchronous service: a layered architecture with the execution service as the sole owner of orders, centralized risk configuration, unit tests on the money path, demo mode as the safe default. Alongside it, a signal engine with LLM-based signal scoring and an analysis module built as a LangGraph graph. Private code, discussed as a case study in interviews.
MORE — ARCHITECTURE & COMPETENCIES
- The service: an async FastAPI service with a layered architecture — connectors → analysis → an execution service as the sole owner of orders. Centralized risk configuration, demo mode as the safe default.
- Tests where money moves. Unit tests concentrated on the money path: loss limits, pause-after-loss, signal-age validation.
- Alongside: a 12-rule volume-price signal engine with a live candle-by-candle loop and LLM-based signal scoring; the analysis module as a LangGraph StateGraph with a checkpointer and an interrupt as the autonomy boundary.
Atelier
AI in professional development · EdTechA year-long professional-development program for someone entering the styling profession, led by an AI agent under my supervision. A daily newsletter generated from web research and the participant's profile, audio lessons released one per day, a dashboard with the day's task, and a feedback loop: the participant's entries feed the next issues.
MORE — ARCHITECTURE & COMPETENCIES
- A headless agent on a daily cron generates each issue from web research, the participant's profile and the program's weekly themes; an anti-repetition rule makes it read the last 14 issues before writing a new one.
- Audio lessons and a dashboard. TTS lessons released one per day from a queue; a dashboard with the day's task; entries and check-ins feed back into the next issues.
- Curriculum built around adult learning. A year-long program map with dosing, streaks and support instead of accounting.
A lot of what I have been doing for years goes by the names of libraries I have never touched. If one of those names comes up, I say I don't know it. Then I take a project that needs it and learn it by building.
The biggest gain often comes from deleting a step, not from adding AI. In my own platform I removed a feature that cost up to six minutes and fourteen cents per trade and produced no evidence in 354 cases. Code takes the rules, an agent takes the steps that need judgment based on history, and a person stays where a mistake is costly.
The most important architectural decisions are about what the system must not do. The session plan takes effect only after the trader approves it. The model has no write path to anything that touches money. The market agent never trades on its own.
Deterministic code computes the metrics, the model interprets, the human reviews after the fact. A test must fail before the fix. Models are chosen on test cases, not on reputation.
I caught sycophancy in my own AI mentor: it anchored on the user's emotional self-assessment and confirmed it instead of checking it against the data. A mentor that doesn't just agree has to be designed — and measured.
Get in touch
Email·····LinkedInlinkedin.com/in/janusz-lenkiewiczXx.com/lenkiewjProducttraderaiassistant.comI help companies find where AI really improves a process, and then build it: process analysis, agents inside the tools people already use, measurement before and after. I'm also open to AI engineering roles on LLM products.
If you want AI to really improve the work and cut costs in your company — and not be another chatbot that doesn't understand your business — let's talk. B2B contract, fully remote.