EN PL DE
Contact
Krzysztof Kaim

AI-native systems, built with production discipline.

Agentic engineering, MCP integrations and enterprise software grounded in systems that have to survive production.

Explore work ↘Kaimtosh mode
Senior Software Engineer · AI Systems & Agentic EngineeringKraków, Poland · Remote
@krzysztofkaim
GitHub activity · 13 mo.
…0 points scored
GitHub ↗
Public activity by @krzysztofkaim
LessMore
Kaimtosh Classic
Profile Card / System Ready
KAIM / 01
Krzysztof Kaim

Senior Software Engineer · AI Systems & Agentic Engineering

Location
Kraków, Poland · Remote
Contact
—
Status
Production ready
functional domains in Manufaktura MES/APS38
active REST endpoints across Manufaktura396
xUnit and Vitest test methods protecting regression1,789
machines represented in telemetry flows54+

KAIM / WORK LIBRARY

Start with the systems that define the work, then inspect the evidence behind them. Full case studies have canonical pages; archive files form a compact inspection layer.

Full case Quick inspect

01 / FEATURED SYSTEMS

WHAT / ROLE / PROOF are visible up front. Ready entries continue into their canonical case studies.

01 / SYSTEM PRODUCTION / CLIENT NDA

MES / APS · production system

Manufaktura

PRODUCT PREVIEW
LIGHT LIGHT 50% DARK 50% DARK
WHAT
Production MES/APS spanning planning, execution, warehouse, ERP and machine-state telemetry.
ROLE
Production · sole technical owner
PROOF
38 domains · 396 endpoints · 1,789 test methods
02 / SYSTEM ACTIVE INDEPENDENT PRODUCT

Parcel intelligence · geospatial decision support

Okolica Działki

PRODUCT PREVIEW
LIGHT LIGHT 50% DARK 50% DARK
WHAT
Parcel-level decision support combining cadastral, mobility, planning, terrain and risk evidence.
ROLE
Product architect · full-stack engineer
PROOF
6 domains · 10+ source families · 60 regression tests
03 / SYSTEM IN PREPARATION

Agentic delivery

Agentic Delivery

PRODUCT PREVIEW
PREVIEW IN PREPARATION Visual material will appear after the current revision is complete.
WHAT
Repository-aware agentic delivery workflow with constrained tools, validation and review gates.
ROLE
AI-native software delivery
PROOF
MCP · validation · independent review
Case study in preparation…

02 / EVIDENCE ARCHIVE

Case files, runtime traces, production signals and modernization records. Open a file for a compact evidence view; when it belongs to a flagship system, continue into the full case study.

Case files

Problem, engineering move and outcome kept as compact inspectable narratives.

2 case files Inspect files above ↗

Runtime traces

Execution evidence from browser-native model internals rather than a prerecorded visual demo.

3 traces Inspect files above ↗

Production evidence

Counts, acceptance and profiling signals attached to production delivery.

3 signals Inspect files above ↗

Modernization records

Operational modernization work that is useful evidence even without a standalone flagship case.

1 record Inspect files above ↗
01AI-native engineering

Turning AI from autocomplete into an engineering system.

The goal was not to generate more code. It was to create a controlled delivery loop where agents receive the right repository context, use constrained tools, prove their work and hand decisions back to a human release owner.

01 · Problem

AI speed without engineering control is just faster uncertainty.

Long-running software work needs continuity, explicit context boundaries, repeatable validation and a way to distinguish model confidence from evidence.

02 · System

Repository-aware context + agents + MCP + independent review.

Tasks are decomposed into bounded stages across architecture, implementation, tests and documentation. Tool access is controlled, acceptance criteria are explicit and validation is treated as a first-class output.

03 · Outcome

A delivery workflow designed for compounding context, not one-shot prompting.

The workflow keeps human ownership of merge and release while moving repetitive analysis, implementation and review into a structured agentic loop.

MCPcontrolled tool integrations
Repo-awarecontext grounded in the actual codebase
Review gatesindependent validation before release
Human-ownedmerge and production decisions
AgentsMCPContext engineeringEvaluationSoftware delivery
02Production platform

Manufaktura: one application owner across an operational production path.

A live MES/APS where planning, execution, warehouse, ERP and machine telemetry have to agree on the same operational state.

01 · Problem

Planning, execution, stock and machine state lived in different operational worlds.

The platform had to model production intent and execution across multiple machine types, halls, warehouse flows, ERP data and operator-facing kiosk workflows.

02 · Build

Domain model first, then interfaces around it.

I built the platform in .NET 10, EF Core, PostgreSQL, React and TypeScript, defined application contracts for PLC/machine-state ingestion and owned security, observability, tests and deployment guidance.

03 · Proof

Production behavior measured, tested and accepted with the client.

The work included UAT resolution, regression evidence, training, handover and profiling. Major N+1 hotspots were removed, cutting measured backend resource use by up to roughly 80% in profiled workflows.

38functional domains
396active REST endpoints
1,789automated test methods
112persistence entities
.NET 10ReactPostgreSQLOpenTelemetryERPUAT
Continue to full case study
02Browser-native inference

GPT Nano / Browser Runtime

A real transformer executes entirely in the browser through native WebAssembly. The interface exposes the actual forward pass as an inspectable system: intermediate tensors, attention weights, residual state and 42 observable stages instead of a simulated visualization.

01 · Runtime

Inference stays inside the browser.

A native WASM module executes the model locally with no external model API. The runtime owns the real learned state and exposes intermediate tensors directly from WebAssembly memory.

02 · Inspection

The visualization is driven by real model state.

The SolidJS interface and Three.js scene map the current forward-pass operation to live tensors, attention matrices and residual-space vectors. Users can move through all 42 observable stages and inspect how state changes between them.

03 · Interaction

The model is an instrument, not a prerecorded animation.

Token sequences can be changed, passes traced and tokens generated interactively. The 3D scene follows the selected operation while the inspector exposes the corresponding numerical structure and metadata.

42observable forward-pass stages
3transformer blocks
3attention heads
48model channels
WebAssemblyThree.jsSolidJSTransformersBrowser inference
QAProduction evidence

Delivery should leave evidence, not just a release.

Across factory software and modernization work, the proof lives in measurable system scale, automated checks, UAT resolution, profiling and deployment behavior, not in a polished demo alone.

01 · Scale

Scale was treated as a model to understand, not a vanity metric.

The static audit found 38 frontend functional domains, 68 application views, 396 active REST endpoints and 112 persistence entities. Those counts describe the architecture surface; they are evidence of scope, not a quality score by themselves.

02 · Acceptance

Quality evidence stayed attached to delivery.

The audited regression surface contains 1,789 automated test methods: 955 backend xUnit methods and 834 frontend Vitest methods. Acceptance, regression and handover evidence sit alongside those repository counts rather than being collapsed into one vanity number.

03 · Profiling

Performance changes were measured against real workflows.

OpenTelemetry and profiling removed major N+1 hotspots, reducing measured backend resource use by up to approximately 80%. Earlier modernization work reduced browser memory by roughly 70% in representative large-dataset views and cut repeated deployment time by about 95%.

396active REST endpoints
1,789automated test methods
38functional domains
~80%backend resource reduction in profiled workflows
UATxUnit / VitestOpenTelemetryChrome DevToolsDelivery automation
03Modernization record

Production platform modernization

A client-safe record of stabilizing and modernizing an inherited production application: tracing cross-layer failures, hardening data behavior, restoring live UI state and replacing fragile release practices with a repeatable delivery loop.

01 · Inherited system

Modernization started with production behavior, not a greenfield rewrite.

The application already carried business rules, operator workflows and machine-state paths. Work began by tracing failures across frontend, backend and persistence, separating architectural debt from genuine domain constraints before changing behavior.

02 · Reliability

Concurrency and stale state were treated as system problems.

A persistence path that had outgrown its early configuration was hardened for concurrent read/write behavior. In parallel, the React surface was changed to reflect production updates without manual refresh, while request tracing exposed subtle status-mapping defects hidden behind a long data path.

03 · Delivery

Manual server copying became a repeatable release path.

Deployments had depended on moving compiled builds between machines by hand. The modernization work moved toward automated, versioned delivery and a safer development environment so iteration no longer depended on repetitive remote-copy operations against a live system.

04 · Product reasoning

Ambiguous requirements were converted into operational models before implementation.

Planning, machine assignment and progress views were worked through as scenarios and visual prototypes before code was committed. That made hidden edge cases visible early and kept the implementation tied to how planners and operators actually reason about production.

WALpersistence concurrency hardening
LiveUI state propagation restored
CI/CDmanual release path modernized
Scenario-ledrequirements translated before build
.NETReact 18TypeScriptCI/CDOperational UX

Interactive model · GPT Nano

A real 3-block, 3-head, 48-channel transformer runs entirely in the browser. Change the token sequence, walk through 42 observable stages and inspect the tensors, attention weights and residual stream produced by the actual WASM forward pass.

Forward-pass microscope Real weights. Real tensors. Zero server inference.
85,728 parameters42 stages3 × 3 heads11-token context
Case study in preparation

Real tensors · native WASM · browser-only inference

GPT Nano / Forward-pass microscope

0 params · 0 B
LOADING
LOADING
Model graph42 observable stages
3 blocks3 heads48 dmodel11 context
3 ops
B1·ATTN
12 ops
12 ops
3 ops
negativepositive
Sequence · click seed tokens to cycle A/B/C
Forward-pass microscope
B1·ATTN07 / 42
Compute only on interaction · residual stream is static while idle6 / 11 positions · 0 live values · orbit with dragInfluenced by llm-viz
Drag to orbit · wheel / pinch to zoom · hover sequence to inspect position · double-click to recenter

Loading the real model.

weights + native compute core · zero server inference

Focus

I am deliberately moving the center of gravity toward AI-native engineering without discarding the part that matters most: architecture, reliability, observability, security and delivery under real operational constraints.

01

AI systems & agentic engineering

Agent workflows, MCP integrations, context engineering, tool orchestration, evaluation and guardrails alongside browser-native inference and LLM platform architecture.

02

Production-grade platforms

Enterprise and industrial systems across .NET, TypeScript, data, integrations and observability. The same discipline that keeps operational software alive is what I bring to AI systems.

03

Technical ownership & modernization

Architecture, implementation, performance, security, testing, deployment, UAT and handover stay under one engineering owner. That includes stabilizing systems that cannot simply be rewritten from scratch.

Tooling / stack
MCPAgent workflowsContext engineeringEvaluationC#.NET 10ASP.NET CoreEF CoreReact 18TypeScriptPostgreSQLSQL ServerSignalROpenTelemetryxUnitVitestDockerGitHub ActionsCloudflareAWS

Experience

The trajectory runs through infrastructure, security, full-stack products and manufacturing systems into AI-native engineering. The common thread is ownership: understand the domain, build the system, measure it and carry it into production.

Manufaktura MES/APS · client NDA

Technical Owner / Sole Full-Stack .NET Engineer · contract via Vapture

Production Manufaktura MES/APS: 38 functional domains, 396 active REST endpoints, 112 persistence entities and 1,789 automated test methods, with machine telemetry flows covering 54+ machines. Also designed and operated a repository-aware agentic delivery workflow using custom agents and MCP tools.

NATA Automation

Full-Stack Software Engineer / MES Engineer · contract via Vapture

Frontend modernization, production-domain logic, deployment automation, SignalR machine updates and authentication / credential-storage modernization.

Vapture · Independent Software Consultancy

Founder / Software Consultant & Full-Stack Engineer

Five long-term NDA clients across healthcare, travel, localization and enterprise software; full SDLC ownership from discovery to maintenance.

WSEI Kraków

Software Developer & Project Lead

Internal .NET and WordPress systems, Azure environments and cross-functional leadership for hackathons serving 100+ participants.

Archman

Penetration Tester & Security Consultant · part-time

Black-box testing and OWASP Top 10 assessments of an enterprise ECM platform using Burp Suite, Nmap, OWASP ZAP and Wireshark.

Wieliczka Salt Mine

Database Administrator & Network Specialist

Network-topology and infrastructure handover documentation plus Oracle Database migrations.

Notes

Opinionated notes on agentic engineering, context, MCP, production architecture, performance and the decisions that make software dependable.

All notes
AI Engineering2 min

Agents need release engineering, not just better prompts

A practical model for turning agentic coding from an impressive demo into a controlled delivery loop with context, evidence and human-owned releases.
Delivery2 min

UAT is not the end of development

What resolving 112 client-reported UAT issues taught me about treating acceptance as a production-design feedback loop, not a release gate.
AI Engineering2 min

Treat MCP as an operational contract

Why MCP integrations become more useful when you design them like production interfaces: narrow capabilities, explicit trust boundaries and observable tool calls.