Expertise
AI systems engineer: I treat the model as one component of the larger software system that carries it
Where the provider sits, where the budget is cut, what authority a tool runs with and how output is measured: the page covers these four decisions and the seven areas behind them.
- Since
- 2024 Since
- years
- 2 years
- posts
- 7 posts
- projects
- 16 projects
Me in this ecosystem
I treat AI not as a standalone feature but as a component of a larger software system, and I solve the feature not in the model itself but in the system that carries it in production. To me AI Systems Engineering is not just AI development, ML engineering, agentic AI or AI infrastructure; it is a systems-focused engineering approach tied to all of them. LLMs, RAG, MCP, agents and fine-tuning are today’s technical components of this discipline; when model architectures and protocols change, the questions of architecture, integration, security and operation stay where they are.
This page covers four topics in its own right: AI Systems Engineering, Retrieval-Augmented Generation, AI Agents and Model Context Protocol. I keep two things apart: the seven areas below are the scope of the discipline, and the links in this section are the examples visible on this site. There is also work I do not detail here because it is commercial; I wrote it up separately in the cards and in the note at the end of the page.
All four have a visible example on this site. The gateway side is in the AI gateway product and its labs record, the work left after the RAG decision is in a separate post, and the MCP side is in the documentation server product and the one-server-per-project post. Where an LLM enters the development loop is in the code-review CLI and the AI self-review post, and the question of abstracting the provider is in a Just Ask answer. The book-length version of the agent side is Engineering Reliable AI Agents; a skill that drafts a fix plan from a Sentry error is a small example that touches no file without approval. Evidence for my non-AI event-driven and queue work is in a separate book.
The seven areas of the discipline
I treat AI as a component of a larger software system, not a standalone feature; the seven areas are one whole, from designing that component to operating it.
-
AI Systems Architecture
Architecture is the backbone of AI Systems Engineering. In AI-native and AI-enabled systems I separate the model, application and infrastructure layers and keep components replaceable. In a provider-agnostic architecture, changing the model should leave the application untouched; I build that with a layer such as an AI Gateway, with fault tolerance and scalability in mind.
-
Model Engineering & Customization
I own model selection and evaluation, and domain-specific adaptation. Fine-tuning and efficient methods such as LoRA/PEFT, model training with TensorFlow and PyTorch, and Machine Learning Research sit inside this area. I reduce latency and cost with Inference Optimization and put the model behind an API with Model Serving; small, local and open-weight models are among my options.
-
Agentic AI & Orchestration
I treat AI Agents as unreliable decision-makers and run them inside control systems: the model proposes, code decides. In Tool Calling I design the tool contract, permissions and state; in Human-in-the-Loop I decide where human approval sits. Protocols such as the Model Context Protocol and the Agent2Agent Protocol, and orchestration and authority boundaries in Multi-Agent Systems, belong to this area too.
-
AI Integration & Data Pipelines
In Retrieval-Augmented Generation the whole pipeline is mine, from parsing a document and drawing chunk boundaries to producing Embeddings and fusing Vector Search with full-text search. I build third-party and enterprise integrations, ETL/ELT flows, event-driven workflows and queues as parts of the data pipeline around the model.
-
AI Infrastructure & Platform Engineering
I build AI Gateways, model routing and multi-provider integration, self-hosted systems, containerized deployment and AI delivery pipelines. Resource management for inference workloads, Model Serving on GPUs and Kubernetes, and infrastructure automation are the everyday work of this area.
-
Reliability, Security & Observability
An unreliable AI system is a risk, not a feature. I design guardrails and policy enforcement, Prompt Injection and tool execution security, data privacy and access control. I manage tokens, latency and cost as a budget; I watch requests with LLM Observability, catch regressions with LLM Evaluation, and contain failure with retry, timeout, fallback and circuit breakers.
-
Applied AI Engineering
I apply AI to real problems: extending an existing software product with AI capabilities, AI-assisted automation, developer tools and moving a research prototype into a production system belong to this area. The measure is not how impressive the model is but whether the problem is solved and the system stays operable.
Decisions I make in an AI feature
Before which model gets chosen, these four decisions around the model set how long the system lives.
- 01 Where the model sits
- I put the model behind an interface instead of embedding it in the application. The cost is an abstraction layer and giving up provider-specific features; in return, changing the model or the provider is a configuration change, not a rewrite.
- 02 Budget
- I set tokens, latency and cost when the request is designed, not when the invoice arrives. Because output tokens are only final once the response is complete, a budget limit cannot stop a single request midway; the overshoot is at most one request, and the one rejected is the next.
- 03 Authority
- Every tool I give an agent is an authority. I define tools narrowly, tie irreversible actions to human approval, and treat any text that enters the model's context as input that can steer it.
- 04 Measurement
- I do not judge output quality by looking once; I measure it with an evaluation set that can be rerun. When the model, the prompt or the retrieval changes, the regression should show up there first, not with the user.
The limit of the discipline
AI Systems Engineering is not only AI development, only ML engineering, only agentic AI or only AI infrastructure; it is the systems-focused engineering approach where they meet. That is why I do not tie the expertise to one technology, provider or trend. LLMs, RAG, MCP, agents and fine-tuning are today's technical components; when model architectures and protocols change, the questions of architecture, integration, security and operation stay where they are.
Recent writing in this area
You chose RAG. The real work starts now
RAG or fine-tuning gets answered everywhere. The three questions left after it — the key, the model choice, the budget — get answered nowhere.
The third MCP server was reasonable. The rest were not
MCP was the right answer for giving an agent a project's documentation. As the count grew, the servers themselves became the thing needing maintenance.
What I have built in this area
Serving the documentation of dozens of projects from one server
A multi-tenant documentation server that gives every project its own MCP endpoint and keeps the documents on your own machine.
What it does today
Makes a project's folder, git repository, Obsidian vault or Notion workspace searchable behind a single MCP endpoint, so an agent reaches the documentation without the data going to a third party. Anyone who can run Docker can host it and manage it from the dashboard.
A 4X that ends in one sitting: the constraint chose the scope
A dice-free strategy core that resolves 480 hexes in 60 turns and runs offline in the browser; it shipped as Regnarium, a 4X match in one sitting.
What it does today
Runs a full 4X match on a 480-hex map in at most 60 turns; rules, map generation and the opponent AI live in one pure TypeScript core, and combat rolls no dice. Anyone with half an hour and an appetite for strategy can open it in a browser.
A deterministic puzzle on a node-and-edge board, offline-first; one TypeScript core feeds 36+6 levels to both web and mobile.
What it does today
Lets the player solve 36 levels + 6 hidden levels on a node-and-edge board through fully deterministic moves, with no luck or reflexes involved; a single TypeScript core drives both the web (PWA) and mobile (iOS/Android) client at once. Playable in the browser at silkward.com.
What shipped in this area
Contextator
OngoingFounder & Developer
Tier: Main FocusContextator is a self-hosted, multi-tenant documentation server that takes a project's documentation from wherever it already lives — a mounted folder, a git repository, an uploaded archive, an Obsidian vault or a Notion workspace — and makes it searchable behind a single MCP endpoint. Every project gets its own URL and its own document collection; embeddings are generated on the machine's CPU by default, and the documents never reach a third party.
Garajdaş
OngoingFounder & Developer
Tier: Active DevelopmentGarajdaş is a community platform where every car make-and-model has its own club, keeping internal-combustion and electric vehicles under one roof. A single API schema is shared by the web (Next.js) and mobile (Expo/React Native) clients, the design system is defined in one file and synced by hand. The MVP phases are closed, the API has 97 tests; the platform is live.
BabelQueue
OngoingFounder & Developer
Tier: Main FocusBabelQueue is a language-agnostic message queue standard that lets services written in different languages share the same queue without getting trapped by serialization lock-in. Instead of language-specific formats like PHP's serialize(), it defines a strict JSON envelope — frozen at schema_version 1 — that every language can read natively. It runs on Redis and RabbitMQ with no sidecar or broker plugin, with an overhead target of under 2%.
Questions in this area
1 questions answered on this axis.
How should I abstract the LLM provider (Ollama → Bedrock/OpenAI)?
Build one narrow complete(prompt, opts) interface with three implementations picked by config, and treat context window, latency and cost as config.
Technologies I pair it with
-
Python
The main language of my model-training, fine-tuning and data-preparation work.
-
TypeScript
The language I wrote the site's MCP documentation server in.
-
Rust
The language I use for services and tools where performance and memory safety decide the design.
-
PyTorch
The deep learning framework I use for model training, fine-tuning and adaptation with LoRA/PEFT.
-
CUDA
The NVIDIA platform I run training and inference workloads on the GPU with.
-
OpenAI Triton
The language and compiler I use to write custom GPU kernels for inference optimization.
-
NVIDIA Dynamo-Triton
The model serving server, formerly NVIDIA Triton Inference Server, that I use to put trained models behind an API.
-
Kubernetes
The orchestration platform I use to deploy and scale model serving and inference workloads as containers.
-
pgvector
The extension that keeps vector search inside PostgreSQL instead of a separate store; I used it in the site's AI gateway and MCP server.
-
Milvus
The distributed vector database I use for large embedding collections.
-
Chroma
A vector database that can run embedded and sets up quickly for retrieval prototypes.
-
Apache Kafka
The event streaming platform I use as the message backbone of event-driven AI workflows and data pipelines.
-
TensorFlow
The deep learning framework I use in my model-training work.
-
Model Context Protocol
The endpoint the documentation server opens for every project, and the protocol the book treats as a trust boundary.
-
Retrieval-Augmented Generation
The retrieval architecture that builds the model's answer from context fetched out of documents; one of the main components of the site's AI gateway.
Frequently asked
6 questions
-
How long have you worked with AI systems?
Since 2024, 2 years. This site has 7 posts tagged with this area.
-
What do you mean by AI systems engineering?
Integrating AI models into real software systems, customizing and orchestrating them, and running them securely and sustainably. The model is only one component; where the provider, the budget, authority, context and evaluation live is the system's question.
-
Is this expertise only LLM integration?
No. Calling an API or writing a prompt is a small part of the discipline. The seven areas run from model customization to agent orchestration, from data pipelines to infrastructure, from security to observability.
-
What is left after you decide on RAG?
The questions retrieval does not answer: where the provider key lives, which application uses which model, where spending is cut off and how quality is measured. I solve them in the system layer outside the model.
-
Why do you not trust an AI agent?
I assume the model will sometimes be wrong and design around that: the model proposes, code decides. Tools are defined narrowly and irreversible actions are tied to human approval.
-
Should I run one MCP server per project?
What should multiply is not the number of servers but the endpoint and the authority boundary. Connecting an MCP server opens a trust boundary, so each project should get its own endpoint and its own authority; one server can carry that with several endpoints.
Let us work together
If you have work in this ecosystem, tell me what you are building and we will talk about how to build it.