# AIESCU

> AIESCU ships production AI for companies — or teaches you to ship it yourself. Done-for-you builds, self-paced programs, and receipts-first engineering writing.

Full text of the key pages in one file (capped at 100 KB; the rest linked): https://aiescu.com/llms-full.txt

## Pages

- [Home](https://aiescu.com/index.md): what AIESCU is, who it is for, offers, how to engage, FAQ
- [Done-for-you](https://aiescu.com/dfy.md): production-AI consultancy: free scoping call and free scoping week, then a flat $20k 4-week build sprint (flat 25% kill-switch after week one)
- [Do-it-yourself](https://aiescu.com/diy.md): programs and courses
- [The book](https://aiescu.com/book): The AI Entrepreneur, launch-price reservation
- [Live demos](https://aiescu.com/demo): working agent demos
- [Free tools](https://aiescu.com/free-tools): free tools across the product family
- [Agent skills](https://aiescu.com/agent-skills): the 10 most popular agent skills, with a free original comparison workflow
- [Skill Budget](https://aiescu.com/skill-budget.md): calculator for the tokens agent skills and MCP servers cost every conversation, with measured MCP tool-schema costs and skills.sh data
- [Agent skill](https://aiescu.com/skill.md): install skills from the aiescu/agent-skills collection (discovery index: https://aiescu.com/.well-known/skills/index.json)
- [The operator brief](https://aiescu.com/about.md): who builds, how AIESCU ships, the proof, and the engagement terms

## Comparisons

- [AWS Bedrock vs calling model APIs directly: the governance-vs-simplicity call](https://aiescu.com/compare/bedrock-vs-direct-api.md): Bedrock puts models behind your AWS account — VPC, IAM, procurement, one bill. Direct APIs give you the newest models first and a shorter path. The choice is an infrastructure decision, not a model one.
- [Claude vs GPT for agents: which model holds together across a long tool-using loop](https://aiescu.com/compare/claude-vs-gpt-for-agents.md): Not a pricing table. When a model is the backbone of an agent — calling tools, staying coherent over dozens of steps, following instructions inside a loop — the behaviors that matter are different from the ones a one-shot prompt reveals.
- [pgvector vs Qdrant: when Postgres graduates to a dedicated vector store](https://aiescu.com/compare/pgvector-vs-qdrant.md): You already run Postgres and pgvector is holding. The real question is not whether Qdrant is faster — it's which pressure finally pushes vectors out of your database, and why Qdrant is the store to catch them.
- [Temporal vs Inngest: durable execution for AI pipelines, self-hosted or managed](https://aiescu.com/compare/temporal-vs-inngest.md): Both make your multi-step AI workflows survive crashes, retries, and restarts. The split is ownership: Temporal is an engine you run, Inngest is a service you adopt. Pick by which cost you'd rather carry.
- [MCP vs Function Calling: Protocol or Primitive?](https://aiescu.com/compare/mcp-vs-function-calling.md): Function calling is the primitive; MCP is the protocol that makes tools portable across agents. When each is enough, from systems we ship.
- [RAG vs Fine-Tuning: Which One Your Problem Actually Needs](https://aiescu.com/compare/rag-vs-fine-tuning.md): The two get pitched as rivals. They solve different problems — knowledge freshness vs behavior shaping. How to pick, from systems we run.
- [LangChain vs LlamaIndex: which abstraction you'll regret less](https://aiescu.com/compare/langchain-vs-llamaindex.md): LangChain wants to orchestrate everything; LlamaIndex is built around retrieval. Both are abstractions you'll eventually fight. Where each one earns its weight.
- [OpenAI vs Anthropic vs Gemini: choosing an LLM API you won't be married to](https://aiescu.com/compare/openai-vs-anthropic-vs-gemini-api.md): The provider you pick matters less than whether you can swap it. We route production traffic through all three behind one layer. How to choose without lock-in.
- [pgvector vs Pinecone: when your database already is your vector store](https://aiescu.com/compare/pgvector-vs-pinecone.md): Most RAG systems reach for a dedicated vector DB before they need one. If you already run Postgres, pgvector removes a whole system. Where it stops being enough.
- [Pinecone vs Weaviate vs Qdrant: choosing a vector database that survives production](https://aiescu.com/compare/pinecone-vs-weaviate-vs-qdrant.md): You've decided you need a dedicated vector store. Now: managed Pinecone, self-hosted Qdrant, or platform-y Weaviate? Filtering, hybrid search, and multi-tenant ops decide it — not recall.
- [Prefect vs Airflow: which orchestrator for AI pipelines that fail well](https://aiescu.com/compare/prefect-vs-airflow.md): Airflow is the incumbent scheduler; Prefect is the Python-native challenger. For AI pipelines full of slow, flaky LLM calls, the failure model is the real decision.
- [vLLM vs TGI: picking the engine that serves your open model](https://aiescu.com/compare/vllm-vs-tgi.md): vLLM is the throughput-first inference engine; TGI is Hugging Face's batteries-included server. If you're self-hosting an open model, the choice is real. How to pick.
- [Langfuse vs LangSmith: the LLM tracing choice, from a production seat](https://aiescu.com/compare/langfuse-vs-langsmith.md): Langfuse vs LangSmith from a production seat: we run Langfuse, we evaluated LangSmith, and the choice comes down to stack shape and data residency.
- [Datadog vs Grafana for AI workloads: we run both](https://aiescu.com/compare/datadog-vs-grafana.md): Datadog vs Grafana, compared by a team that runs both in production: which questions each tool answers and who actually carries the ops burden.
- [Queues for AI workloads: Celery vs ARQ (and when neither)](https://aiescu.com/compare/celery-vs-arq.md): A 90-second LLM call pins a Celery process and can get billed twice. We run five isolated Celery queues in one system and ARQ in another. How to pick.
- [Airflow vs Celery vs Temporal: picking the spine of your AI pipeline](https://aiescu.com/compare/airflow-vs-celery-vs-temporal.md): Airflow schedules data, Celery distributes tasks, Temporal guarantees workflows. We run all three in production. How to pick, with the scars.

## Guides

- [An agent-skills workflow you can actually verify](https://aiescu.com/guides/agent-skills-production-workflow.md): Try one skill on a small task, measure its context cost, and keep a before-and-after evaluation. A free practical lesson for engineers.
- [How to build a RAG pipeline](https://aiescu.com/guides/how-to-build-a-rag-pipeline.md): An end-to-end walkthrough of a production RAG system: ingestion, chunking, embeddings, vector store, retrieval, reranking, generation, and the eval loop.
- [How to chunk documents for RAG](https://aiescu.com/guides/how-to-chunk-documents-for-rag.md): A practitioner's guide to fixed-size, recursive, semantic, and structural chunking — with the size, overlap, and metadata tradeoffs that move retrieval quality.
- [How to deploy vLLM in production](https://aiescu.com/guides/how-to-deploy-vllm-in-production.md): A practitioner's guide to serving open-source LLMs with vLLM: batching, KV cache, quantization, multi-GPU, autoscaling, and metrics.
- [How to evaluate LLMs](https://aiescu.com/guides/how-to-evaluate-llms.md): A practitioner's guide to LLM evaluation: golden datasets, LLM-as-judge, deterministic metrics, and regression gating in CI.
- [How to fine-tune an LLM](https://aiescu.com/guides/how-to-fine-tune-an-llm.md): A practitioner's guide to deciding when to fine-tune, using LoRA and QLoRA, preparing data, evaluating results, and serving adapters in production.
- [How to monitor LLM apps in production](https://aiescu.com/guides/how-to-monitor-llm-apps-in-production.md): A practitioner's guide to tracing, cost and latency metrics, online quality checks, drift detection, and feedback loops for production LLM systems.
- [How to reduce LLM hallucinations](https://aiescu.com/guides/how-to-reduce-llm-hallucinations.md): Practical techniques to ground, constrain, and verify LLM output so it stops inventing facts in production.

## Glossary

- [What are AI guardrails?](https://aiescu.com/glossary/guardrails.md): Checks around a model that constrain what goes in and what comes out. The reliability layer between a clever demo and something you'd let touch a customer.
- [What are embeddings?](https://aiescu.com/glossary/embeddings.md): Embeddings turn text into vectors, so 'similar meaning' becomes 'close in space.' They power semantic search and RAG — and cap how good your retrieval can get.
- [What are LLM evals?](https://aiescu.com/glossary/llm-evals.md): Evals are automated tests for non-deterministic model output. Without them you're shipping vibes. With them, prompt and model changes stop being scary.
- [What is a context window?](https://aiescu.com/glossary/context-window.md): The amount of text a model can consider at once. Bigger isn't automatically better — models still lose things in the middle, and every token costs money.
- [What is a multi-agent system?](https://aiescu.com/glossary/multi-agent-system.md): Several specialized agents coordinating on a task. Sometimes the right split — often an expensive way to reintroduce problems a single agent avoided.
- [What is a vector database?](https://aiescu.com/glossary/vector-database.md): A vector database stores embeddings and finds the nearest ones fast. Useful — but most teams reach for a dedicated one months before they actually need it.
- [What is an agentic workflow?](https://aiescu.com/glossary/agentic-workflow.md): A fixed sequence of LLM steps you design, not a loop the model steers. Less autonomous than an agent — and for most real tasks, more reliable because of it.
- [What is an AI agent?](https://aiescu.com/glossary/ai-agent.md): An LLM in a loop that can call tools and decide its own next step. Powerful when the task is genuinely open-ended — overkill, and less reliable, when it isn't.
- [What is an AI hallucination?](https://aiescu.com/glossary/hallucination.md): A model stating something false with full confidence. Not a bug to patch away but a property of how LLMs work — which is why systems are built to contain it.
- [What is chunking?](https://aiescu.com/glossary/chunking.md): Splitting documents into passages before embedding them. The unglamorous step that quietly decides whether your RAG system can retrieve a coherent fact at all.
- [What is context engineering?](https://aiescu.com/glossary/context-engineering.md): Deciding what goes into the model's context window — and what stays out. The discipline separating a reliable AI system from one that works until it doesn't.
- [What is fine-tuning?](https://aiescu.com/glossary/fine-tuning.md): Further-training a base model on your examples to shape its behavior. Rarely the fix for 'the model doesn't know our stuff' — that's a retrieval problem.
- [What is LLM-as-a-judge?](https://aiescu.com/glossary/llm-as-a-judge.md): Using one LLM to score another's output. It scales evaluation of open-ended answers — if you remember the judge is fallible and needs its own calibration.
- [What is reranking?](https://aiescu.com/glossary/reranking.md): A second pass that reorders retrieved results by real relevance before they hit the model. Often the cheapest single upgrade to a mediocre RAG system.
- [What is retrieval-augmented generation (RAG)?](https://aiescu.com/glossary/retrieval-augmented-generation.md): RAG fetches relevant documents at query time and feeds them to the model, so answers cite your data, not its memory. The retrieval half is where it breaks.
- [What is the Model Context Protocol (MCP)?](https://aiescu.com/glossary/model-context-protocol.md): An open standard for exposing tools and data to LLMs over one interface. It turns one-off integrations into reusable servers — when the tools are designed well.
- [What is tool calling?](https://aiescu.com/glossary/tool-calling.md): Letting an LLM invoke functions you define — search, queries, actions. It's how models reach past their training data, and how they cause real side effects.

## Research

- [How embeddings work](https://aiescu.com/research/how-embeddings-work.md): From tokens to vectors: how embedding models build semantic space, why similarity metrics work, and how dimensionality and model choice shape retrieval.
- [LLM evaluation methods](https://aiescu.com/research/llm-evaluation-methods.md): A taxonomy of LLM evaluation: benchmarks, LLM-as-judge, human eval, and task-specific metrics — what each measures and when it applies.
- [LLM inference optimization](https://aiescu.com/research/llm-inference-optimization.md): How LLM serving actually works: KV cache, continuous batching, quantization, and speculative decoding — and the throughput-versus-latency tradeoff.
- [Transformer architecture explained](https://aiescu.com/research/transformer-architecture-explained.md): Attention, positional encoding, and stacked layers: how the transformer works and why it scales, for engineers who build on top of LLMs.
- [What is a vector database?](https://aiescu.com/research/what-is-a-vector-database.md): How vector databases work: ANN indexes (HNSW, IVF, PQ), the recall–latency–memory tradeoff, and when you need one versus pgvector.

## Blog

- [The narrow-loop playbook, step by step](https://aiescu.com/blog/narrow-loop-playbook.md): The narrow loop works when the steps run in order. Seven of them, each anchored to real dates from the doc-intel demo: 29 days, 74 commits, $20 a month.
- [It runs itself: the first week of a real AI pipeline](https://aiescu.com/blog/it-runs-itself-first-week.md): Live on June 27. Within four days the model was retired upstream, the UI failed silently, and the timeout budget was wrong. The week-one incident log.
- [Surviving a model migration under live traffic](https://aiescu.com/blog/surviving-a-model-migration.md): Google retired our model snapshot three days after deploy. The fix was one config line, decided months earlier by three structural choices.
- [Silent failures: the observability stack that catches them](https://aiescu.com/blog/silent-failures-observability.md): The scariest failure returned HTTP 200 on every request. Five silent-failure classes from production and the open-source stack that catches each one.
- [Shipping production code with coding agents: the actual workflow](https://aiescu.com/blog/shipping-with-coding-agents.md): The agentic coding workflow behind 74 commits in 29 days: spec first, a fresh agent per task, TDD, two review passes, and an eval gate in CI.
- [How a one-person AI consultancy ships in 4 weeks](https://aiescu.com/blog/one-person-consultancy-four-weeks.md): Spec on May 29, live on Fly.io June 27, 74 commits, one engineer plus coding agents. The setup that makes review bandwidth the only constraint left.
- [Solving almost every problem with AI: the honest version](https://aiescu.com/blog/solve-almost-every-problem.md): The friction from idea to working software collapsed. The friction from working software to a system you can trust in production did not.
- [The captain's agentic engineering workflow, annotated from an operator's seat](https://aiescu.com/blog/agentic-engineering-workflow-notes.md): An ex-Meta L8 walked through his full agentic engineering workflow. My notes after 15+ years shipping: where we converge, and where my pager disagrees.
- [Why most AI agents fail in production](https://aiescu.com/blog/why-ai-agents-fail-in-production.md): AI agents rarely fail because the model is weak. Six failure modes from systems we run, and every one of them lives in the layers around the model.
- [The job market looks stuck. AI engineering is where it isn't.](https://aiescu.com/blog/stuck-job-market-ai-engineering.md): The generalist software lane is crowded and slow. From a hiring seat, demand for engineers who operate models in production is loud and supply is thin.
- [Becoming an AI engineer: the production-first path](https://aiescu.com/blog/becoming-an-ai-engineer.md): Most AI-engineer roadmaps list technologies. This one lists the six places production actually broke for us, because that is what the job defends against.
- [Case study: agent-driven analytics for a Series-B DeFi platform](https://aiescu.com/blog/defi-platform-case-study.md): One production platform, end to end: agents, an MCP toolchain, a queue that survived 429 storms, and the numbers: 99.9% availability, p95 under 300ms.
- [Speech-to-text pipelines that survive real audio](https://aiescu.com/blog/speech-to-text-real-audio.md): Pavleur streams live meeting audio through Deepgram and ElevenLabs. Transcription turned out to be the easy part. The pipeline is mostly failure handling.
- [Evals as CI: the merge gate that catches model regressions](https://aiescu.com/blog/evals-as-ci.md): How to write LLM evals that run as CI: a golden set scored by recorded judge cassettes on every PR, deterministic and free, blocking merges on regressions.
- [RAG vs agentic RAG vs a bigger context window](https://aiescu.com/blog/rag-vs-agentic-rag-vs-big-context.md): Long context vs RAG vs agentic retrieval: one cost curve, three meters. The bill sits per query, in the index, or per model call. Corpus size picks.
- [MCP vs RAG vs agents: three acronyms, one system](https://aiescu.com/blog/mcp-vs-rag-vs-agents.md): MCP, RAG, and agents answer three different questions: knowledge in, actions out, control flow. A map of how production systems compose them, with receipts.
- [Context engineering: how we cut 200 tool definitions to a 9k-token catalog](https://aiescu.com/blog/context-engineering-tool-catalog.md): Context engineering for LLM-based agents, from production: 200+ tool definitions cut to a 9k-token catalog, with the reclaimed budget spent on skills.
- [The anatomy of a production multi-agent platform](https://aiescu.com/blog/anatomy-of-a-multi-agent-platform.md): A production-ready multi-agent architecture: a cheap router up front, expensive specialists behind it, safety in code, and a bypass for the common case.
- [How AI agents remember: checkpoints, skills, and work memory](https://aiescu.com/blog/how-ai-agents-remember.md): The three types of AI agent memory in production: run-scale checkpoints, versioned skills, and source-hashed work memory. The context window is a cache.
- [Inside an MCP tool server: what 850 tools teach you](https://aiescu.com/blog/inside-an-mcp-tool-server.md): MCP server architecture, explained from production: at 850 tools the real work is selection, auth scoping, caching, and loading skills before tools.
- [How RAG actually works in production](https://aiescu.com/blog/how-rag-works-in-production.md): The RAG pipeline steps that decide quality, from a live system: parse, chunk, embed, index, retrieve, generate, with a measured number and CI gate at each.
- ["Free because open source": reading the three meters on every AI system](https://aiescu.com/blog/free-because-open-source.md): The weights are free. Running them is not. Every AI system carries three meters: being ready, per call, and touching the world. Ours, with numbers.

## Legal

- [Terms](https://aiescu.com/terms)
- [Privacy Policy](https://aiescu.com/privacy-policy)