LangGraph Experts in Germany

Product:

• Built a production-ready AI platform for generating brand-aware marketing images and videos from product data, user requirements, and uploaded media.
• Own the platform architecture, technical roadmap, API design, security, deployment workflow, operational reliability, and model-provider strategy.
• Developed the core platform in .NET and built supporting AI and workflow prototypes in Python, applying language-independent API contracts and structured interfaces between services and model providers.
• Implemented reliable background processing with RabbitMQ, persisted workflow state, idempotent handling, retries, failure recovery, logging, secure storage, authorization, and credit accounting.
• Made pragmatic build-versus-buy and model-routing decisions based on reliability, latency, cost, and maintainability rather than novelty.

Agent Orchestration & RAG Systems

• Built and compared agent workflows using Microsoft Agent Framework, LangGraph, and LangChain, including tool use, conditional routing, clarification steps, state management, and hand-offs between agents.
• Implemented reusable .NET components for agents, prompts, tools, model providers, structured responses, and retrieval with pyvector, making it easier to change AI providers without rewriting the core workflow.

• Claude Code subagents, MCP, Pydantic V2, pytest, bandit

• Designed and shipped 3 specialized agents that hand work down a line: a research agent writes a cited implementation spec, a coding agent builds the modular code and its tests, a review agent ranks findings by severity and applies the fixes. Each handoff is a structured document, so no stage depends on another agent's context window.

• Connected the research agent to an academic-research MCP server (Semantic Scholar, ArXiv, Hugging Face Hub, citation snowballing) so every reference traces to a tool result rather than the model. Gated commits behind ruff, mypy, pytest and bandit, required human sign-off before installs and commits, and persisted session state on disk so long runs survive a context reset.

Evidence-led health intelligence platform turning published research into personal health protocols. It scores 430 habits, foods, and supplements against the studies behind them, and moves the score when the evidence moves. Built solo.

• Built the daily ingestion pipeline across PubMed, bioRxiv, and medRxiv: 43,000+ papers from 3,400+ journals processed into 230,000+ typed evidence claims, each one traceable back to the study it came from.
• Designed the six-factor evidence scoring model and the public changelog behind it, so no recommendation ever appears without the papers underneath it. 23,000+ grade changes recorded and explained to date.
• Shipped an entity information model connecting every intervention to its mechanisms, biomarkers, and outcomes: 118 biomarkers with region-specific reference ranges, 77 mechanisms, 32 graded outcomes.
• Built the personalisation layer: blood panel ingestion that reads lab PDFs with a vision model and corrects results for draw time against the user's wake anchor, plus Oura, WHOOP, and Withings integration for daily readiness context.
• Operate eleven specialised review agents over the corpus and codebase, covering paper curation, retrieval quality, health-claim compliance across EU and US regimes, and security.
• Shipped the Evidence Assistant, a RAG assistant that answers from the claim database and cites the underlying papers, plus a B2B practitioner tier, an Expo React Native app, and localisation across 3 languages and 7 markets.

Stack: Next.js 16, TypeScript, Supabase, pgvector, Anthropic Claude, Vercel, DeepInfra.

• Fully on-premises LLM document-examination platform for a compliance-critical banking domain: agentic LangGraph pipeline with deterministic verification, every AI judgment structured and source-anchored; ~960 automated tests, zero data egress
• GPU throughput engineering (quantized serving, speculative decoding, prefix caching): 9.5x extraction speed-up, 500+ multi-document case files per day on a single A100
• AI-native EDI/EDIFACT integration platform (~116k LOC Java 25 / Spring Boot 4, 1,900+ tests): LLM-drafted partner mappings machine-verified before go-live (DFDL conformance, field-coverage checks, dry runs), ~99.5% byte match on real customer files — replacing weeks of manual mapping per partner

Multi-Agent Document-Generation Platform

Problem:

Turn a single prompt into a well-researched, structured and cited document, while keeping the user in control: every stage can be reviewed, corrected or revisited before the system moves on.

Architecture:

A multi-agent system orchestrated by a central controller. More than 20 specialised pydantic-ai subagents (understanding, structuring, planning, research, writing, assembly, cross-reference check, glossary, citation, reference table and more) pass results forward through a shared plan persisted in Postgres (asyncpg); a runner layer dispatches each task by name to its agent, and mechanical steps such as formatting, table of contents and list of figures are deterministic code instead of LLM calls. Provider (Anthropic or OpenAI) is a configuration setting, and responses stream over Server-Sent Events.

Hosting & Infrastructure:

Stateless container run as a Scaleway Serverless Container on a private network with managed PostgreSQL, object storage for finished documents and assets, and centralized log shipping (Loki / Scaleway Cockpit), provisioned with OpenTofu modules and deployed through GitLab CI; usage is metered per API key.

My Contribution & Key Decisions:

• Central decision controller: a satisfaction classifier turns the user's free-text feedback into a verdict (keep working, advance, cancel or revise an earlier task), and a middleware applies it to the plan. Plan progression supports jumping back to earlier tasks and re-running the stages after them.
• Research and writing fan-out: planning produces a plan from which a research-design agent generates individual research tasks and a writing-design agent generates individual writing tasks, each linked to the research it needs. Every task runs in its own dedicated agent with its own conversation history.
• Self-review and human-in-the-loop: after each step a critical-thinking agent reviews the output; the user can accept, refine, or ask questions about a critique before the plan advances.
• MCP integrations: two remote MCP servers, web search and internal document search, connected through pydantic-ai with retries and long-running tool-call timeouts. Classifier agents decide per task whether web search is needed, and a small model condenses raw search results into structured findings before they reach the writing agents.

Usage Metering:

Clients authenticate with an API key validated against a key-management service; consumption is charged in credits calculated from token usage per model plus a markup, and exhausted quota is answered with HTTP 429.

• This project involved extraction of intelligence data to support report writing for a company that provides geopolitical, global, commercial intelligence. The data have been gathered from a number of resources (interview transcripts, online data, internal documents), and then a knowledge base has been build from it. This was the basis of a complex RAG system, that was evaluated against a golden dataset. Agents have been used to find out the contradicting intelligence, the statements supporting each other, and to store back the generated knowledge.

Used: Python, RAG, LangGraph, LangChain, deepeval, MCP

Independently built a data platform with cross-system process monitoring.

• Designed the Bronze/Silver/Gold architecture and Python-based pipelines for diverse operational sources.
• Cleaned, harmonized, and validated data; processed and stored it in Parquet format.
• Tracked data history and built business-focused fact and dimension models for traceable reporting.
• Automated data delivery with Python and Power Automate (desktop and cloud); used SharePoint for archiving and data access.
• Developed the Power BI solution from data preparation through to visualizing process statuses, work progress, and deviations.

Technologies: Python, SQL, Parquet, Power BI, Power Query, Power Automate, SharePoint, Copilot

• AI Integration (LLM & RAG): Designed and built an internal intelligent RAG system (Retrieval-Augmented Generation) based on LLMs, n8n, and vector data to automatically analyze technical documents and error logs.
• Design & Implementation: Designed a robust RS-232/UART communication interface for an SBC-based embedded device used to control medical shaker systems.
• Architecture & Protocol Design: Built a highly maintainable software structure (OOP, SOLID) and defined resilient, hardware-level communication protocols, including multithreading and advanced error handling.
• Quality Assurance & DevOps: Automated testing with xUnit, ran integration tests directly on the hardware target, and maintained technical documentation to strict medical technology standards via Azure DevOps.

Label: C#, .NET, LLMs, RAG, n8n, RS-232, UART, Multithreading, async/await, xUnit, gRPC/protobuf, Blazor, MudBlazor, EF Core, Visual Studio 2026, Azure DevOps

• Fine-tuned and evaluated alternative backbone architectures for the AFFGAN handwriting style encoder to better capture writer-specific features, benchmarking against the original baseline architecture and replacing the legacy VGG19 architecture with a custom Transformer-based encoder.
• Extended the system beyond word-level synthesis to line-level handwriting generation, integrating and adapting an existing line-generation architecture to support full-sentence output.
• Deployed the handwriting generation pipeline as a web application, enabling users to select a writing style, input custom text, and instantly generate a corresponding handwriting image.
• Integrated TrOCR into a teacher–student distillation framework to evaluate and improve readability of generated handwriting, improving OCR accuracy by 20% over the baseline.
• Boosted user-study pick-rates by 40%, demonstrating a significant leap in the perceptual quality and realism of the generated handwriting compared to the baseline model.

Tech: PyTorch, Python, GANs, CNN, ViT, TrOCR, Streamlit, CUDA.

Transmission system operator – network provisioning platform (team lead)

• Designed the saga orchestrator in Python that provisions network fabrics with rollback.
• Split IP, identity, and resource allocation into bounded contexts with their own databases and typed clients.
• Implemented data access using DDD repositories and units of work, with no SQL in the domain code.
• Required integration tests using real PostgreSQL and RabbitMQ containers, and API fuzzing for every service.
• Introduced an agent workflow where a spec starts each change and a human approves every merge.
• Rolled out OpenTelemetry auto-instrumentation through GitOps across eighteen Kubernetes clusters.
• Led incident response for stuck provisioning and recorded every outage as a post-mortem.

Languages and software used: Python, FastAPI, Pydantic v2, SQLAlchemy async, PostgreSQL, RabbitMQ, Celery, pytest, testcontainers, schemathesis, Helm, Flux CD, GitLab CI, OpenTelemetry, pi coding agent.

Software product company – datacenter simulation SaaS (backend development)

• Built the asynchronous simulation pipeline as the second-largest contributor among more than twenty team members.
• Tagged every image by commit SHA and semver in the GitHub Actions deployment workflows.
• Diagnosed the RabbitMQ memory alarm that froze every simulation and fixed the limits in the Helm chart.
• Converted the test suite to function-style pytest, with coverage reported in every pipeline.

Languages and software used: Python, FastAPI, SQLAlchemy, Alembic, Celery, RabbitMQ, Redis, PostgreSQL, S3, EKS, Helm, Keycloak, GitHub Actions, pytest, mypy, ruff, SonarQube.

Internal AI platform – model serving and telemetry

• Built the FastAPI service that deploys open-weight models on GPU tiers as OpenAI-compatible endpoints.
• Upgraded production EKS by two Kubernetes minor versions and fixed zone-bound storage faults.
• Traced every model call, including its token count, cost, and latency, through the OpenTelemetry operator.

Languages and software used: Python, FastAPI, vLLM, LangGraph, pydantic-ai, OpenAI and Anthropic APIs, EKS, Helm, Flux CD, Terraform, GitLab CI, OpenTelemetry, Grafana.

• Architected and built an agentic creative automation platform on Mastra, with a custom RAG pipeline, custom hooks, tools and skills, Chroma for vector storage, and a MongoDB/Express backend.
• Built the agent orchestration layer powering Pixomi's multi-agent workspace, including 72 custom marketing skills, tools and hooks, and a custom context-management pipeline.
• Designed and implemented evals and observability through Mastra studio.
• Onboarded 10 pilot SMB customers producing 10x publish-ready creative output per campaign versus manual production in 3 months.
• Ran customer discovery and pilot feedback loops to shape the roadmap for an AI-native, workflow-based creation platform.

• ▶ Built real-time voice assistant (STT → LLM → TTS pipeline) benchmarking and evaluating multiple STT providers including faster-whisper and Azure Speech. achieved sub-3s latency, Groq API (Llama 3) with multi-turn memory - directly handling edge cases in dictation, names and passcode recognition.

Independent engineering practice focused on custom AI systems, production delivery, and fractional technical leadership.

Selected client engagement: Scalutions

• Role: Serve as fractional CTO and hands-on technical lead, responsible for the architecture and agentic infrastructure behind its managed B2B outbound operation.

• Product: Designed and built OutboundLoop, an agentic SDR operating system for research, qualification, personalized outreach, campaign management, human approvals, measurement, and continuous improvement.

• Scope: Own the full system lifecycle—from business processes and agent behavior to context design, model routing, integrations, evaluation, telemetry, reliability, cost control, and production operations.

• Self-employed · Berlin, Germany
• Co-founded the company and own the entire technical side: product architecture, backend, frontend, infrastructure and operations.
• Designed and built the Automated Booking System (ABS) as well as the core platform and payment logic.
• Development of AI-powered SaaS products, from architecture through backend and frontend to production operation.
• Technical consulting on product architecture, data protection and permissible automation.
• Building, running and monetising my own API products for AI agents, each available as a REST interface and as an MCP server.
• Full ownership of architecture, infrastructure, billing, legal texts and go-to-market.