Denis Geide
AI Engineer
Python
TypeScript
JavaScript
Rust
SQL
C++
Go
PHP
Research Depth & Innovation: 4/10
Invite to interview
Download CVCV
Overview
Technical skills
Projects
Timeline
Roles
Overview
An experienced data-engineering-focused developer at a senior level who builds local-first AI orchestration and knowledge/memory services. The strongest proven skill is designing robust ingestion, privacy-aware knowledge indexing and durable memory storage as seen in services/knowledge/engine.py and services/memory/* (migrations, store and privacy). The public code does not show statistical modeling, model training pipelines, dashboards with business metrics, or explicit ML experiment design and evaluation artifacts.
Phone
Technical skills
Languages
8
Python
TypeScript
JavaScript
Rust
SQL
C++
Go
PHP
Python
9
FastAPI
Pydantic
SQLAlchemy
Alembic
PySide6
Beautiful Soup
Asyncio
HTTPX
Django
Databases
6
SQLite
PostgreSQL
Redis
ElasticSearch
MySQL
pgvector
AI/ML
16
LLM
Qwen
Ollama
OpenAI SDK
Anthropic SDK
Whisper
RAG
Claude
Gemini
LoRA
Open WebUI
LangChain
Stable Diffusion
PEFT
CUDA Toolkit
MLOps
Frontend
4
React.js
Tailwind CSS
Recharts
Vite
DevOps
7
Docker
Git
Rest API
Nginx
Ubuntu
WebSockets
Kubernetes
Other
15
Tauri
Playwright
WooCommerce
WordPress
Runway
LocalAI
GitLab CI
Hatch
PostCSS
CI/CD
Debian
ComfyUI
Adobe Premiere Pro
SLI/SLO/SLA
DaVinci Resolve
Projects
Built a reproducible machine-learning benchmark for predicting English word complexity bands. Prepared and published a balanced 6,000-record dataset, implemented deterministic group-aware train/test splitting, TF-IDF and logistic-regression baselines, calibration analysis, confusion matrices and model cards. Added an optional explicit PyTorch Transformer training loop, FastAPI inference service, Docker packaging and reproducible experiment reports.
Designed and developed a local-first AI orchestration platform that connects local LLMs, repository-aware coding agents, scoped long-term memory, knowledge retrieval, browser automation and explicitly approved cloud escalation behind one interface. Implemented deterministic task routing, context management, permission boundaries, health checks and a versioned bilingual evaluation suite with 117 regression cases.
Built and operated a commercial VPN subscription platform covering the complete customer lifecycle: Telegram onboarding, trial access, payments, automatic VPN provisioning, subscription renewal, customer profiles and support workflows. Integrated Telegram Bot and Mini App interfaces, YooKassa payments, PostgreSQL storage, Marzban API and Xray/VLESS infrastructure. Added lifecycle jobs, reminders, administration tools, rate limiting and operational automation.
Designed and developed a game-inspired English learning platform with structured lessons, adaptive vocabulary practice, focused error correction, achievements and progress tracking. Built the frontend with React and TypeScript and designed a FastAPI and PostgreSQL backend for lesson state, learner progress and adaptive exercise delivery.
Developed an autonomous browser agent with semantic page observation, planning, hierarchical memory, context budgeting and provider-neutral LLM orchestration. The runtime navigates websites without hardcoded selectors, recovers from stale page elements and produces replayable execution reports. Added a security policy that redacts sensitive data and requires explicit confirmation before actions with external effects.
Developed an offline Windows desktop utility for hiding, grouping, pinning and safely restoring application windows. Implemented reversible Windows style manipulation, topmost window control, local recovery state, multilingual UI and a standalone Windows installer. The application works locally without telemetry, cloud accounts or background monitoring.
Designed a multi-tenant B2B platform combining AI-assisted customer support, CRM workflows and electronic document management. Implemented tenant-aware APIs, RAG-based answers, intent and action extraction, ticket routing, document versioning, Redis-backed realtime events, background jobs, RBAC, audit logging and protected file delivery. Added automated testing and a reusable RAG evaluation toolkit covering Recall@K, MRR, nDCG, macro-F1 and latency.
Built a local-first WebSocket debugging workspace for inspecting, filtering, replaying and exporting realtime application traffic. Implemented a virtualized packet timeline, JSON payload inspector, direct and proxy connection modes, configurable environments, protocol-aware decoding and privacy-safe session redaction. The desktop proxy is implemented with Tauri and Rust, while the frontend uses React and TypeScript.
Timeline
MTI University
Associate's Degree
Full-Stack Developer (FastAPI) / AI Engineer
•
Middle
GADE CLOUD
•
Full-Time
Designed and developed end-to-end software products, spanning backend services, database design, and frontend interfaces, with deployment for production environments. Implemented AI-related integrations including local AI systems, RAG, and agent-based workflows. Built and automated infrastructure components for service operations, including containerized environments, monitoring, and web/API backends that support user-facing features.
Python
FastAPI
Pydantic
PostgreSQL
SQLAlchemy
SQLite
Redis
Rest API
WebSockets
Git
Docker
Ubuntu
Nginx
React.js
JavaScript
TypeScript
Vite
Tailwind CSS
Tauri
Rust
PySide6
Alembic
Recharts
Playwright
Beautiful Soup
Ollama
Open WebUI
Qwen
RAG
LLM
Senior AI/ML Engineer
Confidence: Medium LLM Engineer
A senior-level LLM systems engineer focused on building autonomous web agent infrastructure and safe LLM orchestration. The strongest proven skill is agent/runtime design and orchestration - evidenced by AutonomousAgentRuntime in src/scout_pilot/runtime/agent.py which coordinates observation, reasoning, planning, tool execution and evaluation. The public code does not include any model training, experiment tracking, GPU/quantization optimizations or large-scale serving infrastructure.
Model Architecture & Training
1/10
How well models are designed and trained
No model training or architecture engineering - the code integrates hosted LLM providers and implements reasoning/adapter layers but contains no custom training loops, losses, optimizers or model implementations.
Evidence
src/scout_pilot/llm/reasoning.py: ReasoningEngine - provider-neutral orchestration of prompts and context
src/scout_pilot/llm/openai_provider.py: OpenAILlmProvider - adapter for hosted OpenAI inference
pyproject.toml: optional-dependencies include openai and anthropic (integration, not training)
Data Pipeline & Feature Engineering
3/10
How data is prepared for models
Solid semantic observation and context-budgeting code that prepares and truncates page and memory context for LLM inputs, but not a data-engineering pipeline for model training.
Evidence
src/scout_pilot/context/budget.py: ContextBudgeter, token estimation and observation fitting logic
src/scout_pilot/observation/semantic.py: SemanticObservationEngine - builds sections, interactive elements and issues used as LLM context
src/scout_pilot/memory/summarizer.py: DeterministicMemorySummarizer - formats memory records for context
Experimentation & Evaluation
2/10
How results are measured and tested
Basic testing and some evaluation-oriented code exist (unit tests and runtime evaluation events), but no structured experiment tracking, ablation artifacts, W&B/MLflow configs, or published reproducible experiments.
Evidence
tests/test_models.py: unit tests for model-related dataclasses and context behavior
tests/test_config.py: environment/config tests
src/scout_pilot/runtime/agent.py: extensive RuntimeEvent emission used by reporters and dashboards (used for runtime evaluation traces)
MLOps & Deployment
3/10
How models are shipped to production
Thoughtful CLI entrypoints, packaging and runtime reporting with replay/recording, but no large-scale serving stack, Kubernetes/Triton/TF-Serving artifacts or drift monitoring pipelines specific to ML serving.
Evidence
pyproject.toml: project packaging and console script entry (scout-pilot)
src/scout_pilot/cli/main.py: comprehensive CLI orchestration and demo/run modes
src/scout_pilot/reporting/runtime_report.py: RuntimeReportRecorder and replay/report writing
Computational Efficiency
3/10
How efficiently computing resources are used
Efficiency work centers on token/context budgeting and deterministic summarization for LLM cost/latency control; no GPU/quantization/profiling artifacts are present.
Evidence
src/scout_pilot/context/budget.py: context compression, metrics and assembling compact context
src/scout_pilot/runtime/agent.py: emits context_budget_applied events and integrates last_context_metrics into reporting
src/scout_pilot/memory/summarizer.py: deterministic summarizer used to reduce memory size in the LLM context
Research Depth & Innovation
4/10
Depth of research and new ideas
Original system design for autonomous web agents, semantic observation, planning, security policy and deterministic recovery shows research-informed engineering and custom algorithms for agent workflows, but not academic SOTA model research.
Evidence
src/scout_pilot/runtime/agent.py: AutonomousAgentRuntime - non-trivial orchestration of observe-reason-plan-act-evaluate loop
src/scout_pilot/security/policy.py: deterministic security policy with audit trails and classification
src/scout_pilot/planning/provider.py: ProviderPlanningEngine - parsing and revision logic for LLM-produced plans
Expertise
AI Agents & Agentic Workflows• Senior
MLOps & Model Lifecycle• Middle
Technologies
MLOps
SQL
PostgreSQL• since 2024
Redis• since 2024
Rest API• since 2024
Qwen• since 2024
pgvector
Stable Diffusion
LoRA
SQLAlchemy• since 2024
CUDA Toolkit
Debian
WebSockets• since 2024
Beautiful Soup• since 2024
Anthropic SDK
ComfyUI
Ollama• since 2024
Open WebUI• since 2024
OpenAI SDK
PEFT
Git• since 2024
Docker• since 2024
Gemini
Ubuntu• since 2024
Nginx• since 2024
LLM• since 2024
RAG• since 2024
Runway
PySide6• since 2024
Hatch
Alembic• since 2024
SLI/SLO/SLA
Recommendations
- Develop deterministic agentic features and safety rules - expand and harden the SecurityPolicy and confirmation flows for production workloads.
- Build RAG-style retrieval connectors and evaluation harnesses - add reproducible evals, W&B/MLflow tracking and baseline comparisons for reasoning outputs.
- Implement lightweight deployment pipelines for hosted inference - add container images, CI/CD manifests and simple inference wrappers (latency and cost budgets).
- Add end-to-end integration tests and more unit tests for planning/reasoning edge cases to increase confidence in recoveries and failure handling.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Data Scientist
Confidence: High Data Engineer
An experienced data-engineering-focused developer at a senior level who builds local-first AI orchestration and knowledge/memory services. The strongest proven skill is designing robust ingestion, privacy-aware knowledge indexing and durable memory storage as seen in services/knowledge/engine.py and services/memory/* (migrations, store and privacy). The public code does not show statistical modeling, model training pipelines, dashboards with business metrics, or explicit ML experiment design and evaluation artifacts.
Statistical Rigor
1/10
Correct use of statistics
Minimal statistical rigor - no evidence of hypothesis testing, uncertainty quantification, or experiment design; tests are deterministic unit/integration checks rather than statistical evaluation.
Evidence
locestra/tests/test_routing_eval.py: corpus-based routing tests and fixed-accuracy assertions (deterministic test cases rather than statistical analysis)
Data Wrangling & Cleaning
8/10
Preparing and cleaning data
Strong data ingestion, provenance, privacy and sanitization code - careful parsing, secret-detection, chunking, repository-aware indexing and token-budgeting show mature pipeline engineering.
Evidence
services/knowledge/parsers.py: parse_source and extract_facts implementations (chunking and normalization)
services/knowledge/engine.py: import_source and index_repository (repository traversal, reuse checks, blocked-source handling, generation staging)
services/memory/privacy.py: inspect_memory_payload and secret-detection logic
Exploratory Analysis & Visualization
1/10
Exploring and visualizing data
Exploratory analysis and visualization are not a focus - some result notes and before/after assets exist for demos but no structured EDA or written interpretation of data findings.
Evidence
image-inpainting-cleanup-showcase/README.md: before/after result notes and demonstration images
Predictive Modeling
2/10
Building models that predict
Integrates and orchestrates LLMs and speech models (runtime calls, streaming handling) but contains no predictive-model development, training, or evaluation workflows.
Evidence
services/gateway/app.py: local_chat, preopen_local_stream and openai_response functions (streaming LLM orchestration, SSE handling)
services/voice/app.py: WhisperModel usage for transcription
Business Insight & Impact
3/10
Turning analysis into business value
Product-minded engineering with routing, capability health and error codes linking behavior to operational outcomes, but there is little explicit business-metric analysis or cost-of-error modeling.
Evidence
services/gateway/app.py: build_route_decision, route_preview and the decision->error code mapping for different failure modes
services/knowledge/engine.py: build_context enforces token budgets and evidence trimming (operational impact constraints)
Reproducibility & Notebook Hygiene
7/10
Clean, repeatable analysis
Good reproducibility and hygiene: extensive unit/integration tests, controlled migrations, deterministic verification and documented backup/restore workflows.
Evidence
services/memory/migrations.py: migrate_database, backup_database and verify_database (transactional migrations and verification)
locestra/tests/test_memory_store.py: thorough unit/integration tests around persistence, concurrency and privacy behaviors
Expertise
Streaming• Senior
Industries
Artificial Intelligence• Senior
Technologies
Python• since 2024 • Senior
FastAPI• since 2024
SQLite• since 2024
Asyncio
Whisper
Pydantic• since 2024
HTTPX
Models• mentioned only
Ollama• mentioned only
Qwen• mentioned only
RAG• mentioned only
Recommendations
- Develop streaming LLM gateways and SSE-backed APIs that require careful cancellation and journaling (use preopen_local_stream and track_stream_task as blueprints).
- Implement privacy-aware knowledge ingestion and repository indexing pipelines - extend the imports/index_repository flow for new content adapters and provenance tracking.
- Build and maintain durable local memory services with transactional migrations and backup/restore workflows (follow services/memory/migrations.py patterns).
- Drive product-facing routing and capability-health work that ties runtime capability checks to safe fallbacks and explicit error codes (use build_route_decision and collect_gateway_health patterns).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Backend Developer
Confidence: High Generalist
A backend-focused developer at a Senior level who designs and implements non-trivial runtime systems for autonomous LLM-driven browser agents. The strongest proven skill is building a robust autonomous runtime - evidenced by AutonomousAgentRuntime (ScoutPilot/src/scout_pilot/runtime/agent.py) which wires observation, reasoning, planning, tool runtime and memory with explicit state transitions, safety checks and deterministic fallbacks. Public code does not show database schema migrations, external API (HTTP) surfaces, or distributed-system load testing artifacts, so those areas are not evidenced for production readiness.
API Design
5/10
How well APIs are designed
API design is pragmatic and consistent for internal boundaries - there are structured runtime events, a provider protocol and an idempotency signature for tool requests, but no public REST/HTTP API design or versioning artifacts to evaluate.
Evidence
ScoutPilot/src/scout_pilot/runtime/agent.py: _tool_request_signature (hashing of ToolRequest for idempotency/blocking repeated actions)
ScoutPilot/src/scout_pilot/runtime/agent.py: _event (RuntimeEvent construction and structured details)
ScoutPilot/src/scout_pilot/cli/main.py: build_parser (CLI surface design with clear subcommands/options)
Data Layer & Database
2/10
Working with databases
Data-layer usage is present (memory store abstraction and memory-record patterns) but there is no evidence of a DB schema, migration history, transaction boundaries or tuned queries.
Evidence
ScoutPilot/src/scout_pilot/runtime/agent.py: _update_memory / _remember_* methods (use of MemoryStore protocol)
ScoutPilot/src/scout_pilot/runtime/agent.py: _memory_summaries (aggregation of memory summaries from MemoryStore)
Scalability & Performance
4/10
Handling load and speed
There is attention to bounded execution and limits (iterations, elapsed time, token budget) and deterministic fallbacks, but no explicit connection-pooling, cache invalidation strategies, queue-based decoupling or load-test artifacts.
Evidence
ScoutPilot/src/scout_pilot/runtime/agent.py: max_iterations and max_elapsed_seconds enforcement with _progress() and protective partial results
ScoutPilot/src/scout_pilot/runtime/agent.py: _context_budget_event (context budgeting integration and emission of metrics)
System Architecture
5/10
Overall system structure
Clear modular service decomposition is visible - observation, reasoning, planning, tool runtime and memory are wired together deliberately and the runtime implements an explicit state machine and transitions, showing non-trivial architecture decisions.
Evidence
ScoutPilot/src/scout_pilot/runtime/agent.py: AutonomousAgentRuntime.__init__ wiring observation_engine, reasoning_engine, planning_engine, tool_runtime, memory
ScoutPilot/src/scout_pilot/runtime/agent.py: state transitions via _transition/_set_state and explicit AgentState lifecycle handling
Security & Auth
6/10
Protecting data and access
Strong security/defensive patterns for this domain: redaction of sensitive tool arguments, security decision propagation from tool results, and confirmation constraints are integrated into runtime flows.
Evidence
ScoutPilot/src/scout_pilot/runtime/agent.py: _redact_tool_arguments (redacts passwords, tokens and other sensitive fields)
ScoutPilot/src/scout_pilot/runtime/agent.py: _security_decision_from_tool_result (maps tool execution results into security decisions)
ScoutPilot/src/scout_pilot/cli/main.py: runtime created with confirmation_constraints/security_constraints when launching AutonomousAgentRuntime
Reliability & Observability
6/10
Stability and monitoring
Good reliability and observability signals - structured runtime events, durable memory records, guarded updates, logging and exception handling with fail/partial-result semantics and graceful cancellation/confirmation flows.
Evidence
ScoutPilot/src/scout_pilot/runtime/agent.py: try/except around the main run loop with logger.exception and fallback to _fail
ScoutPilot/src/scout_pilot/runtime/agent.py: _event construction and many yield points producing structured RuntimeEvent objects
ScoutPilot/src/scout_pilot/runtime/agent.py: _update_memory wrapped with exception handling and logger.warning on failure
Expertise
Backend AI & LLM• Senior
Python• Senior
Industries
Software• Senior
Technologies
PHP
Rust• since 2024 • Junior
WordPress
WooCommerce
Tauri• since 2024
Recommendations
- Develop autonomous LLM-driven runtime backends and orchestration layers (agent loop, tool adapters, security/confirmation flows).
- Implement safe browser automation and RAG-style data-collection pipelines that require strict argument redaction and user confirmation logic.
- Build developer-facing CLI tooling and deterministic demos that integrate observation, planning and reporting (reports/replays).
- Work on observability and reliability features for AI runtimes - structured events, context budgeting, and graceful shutdown/partial-result handling.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: