Blog

A deep dive into the "design-by-intuition" tax in AI engineering, comparing convergent and divergent agent loops. It introduces agent-evolutions, a genetic search framework that spawns variants in parallel, evaluates them against frozen binary gates and numeric rubrics, and relies on a robust file-based sub-agent contract rather than chat parsing.

Many coding agents fail because they improvise internal planning loops, leading to unchecked code or runaway sessions. This article details how externalizing a structured Plan-Do-Check-Act (PDCA) engineering loop into a disk-based workflow acts as a leverage multiplier. By forcing agents through an explicit, step-by-step verification process, developers can reliably guide agents to finish what they start with minimal human intervention.

Rosie is iFood's AI support agent, serving millions of customers across Brazil. Rather than trying to eliminate latency, the team designed the system around it. In this conversation, César Gomes explains how iFood uses asynchronous workflows, specialized agents, rollback strategies, delayed memory consolidation, and a reviser agent to keep conversations responsive while reducing costly hallucinations. The result is a production-ready architecture focused on one outcome: shortening the path from customer problem to resolution.

Letting coding agents search the web for documentation wastes tokens, increases latency, and risks importing outdated or incorrect API patterns. To resolve this, this article presents `agent-docs`, a system of local references stored directly within the repository. By instructing agents to search local Markdown documentation maps before attempting web queries, developers can ensure that agents always build on correct, version-aligned instructions.

This post compares the leading model serving runtimes for deploying production ML APIs, including TensorFlow Serving, TorchServe, BentoML, and NVIDIA Triton Inference Server. It breaks down the strengths, trade-offs, and key selection criteria—such as framework support, inference performance, infrastructure integration, and ease of use—to help teams choose the best runtime for their machine learning workloads.

This is our final installment of a series that studies 20+ tools in the AI cognition landscape rated against organizational requirements. We present a tactical guide for choosing a memory foundation based on your specific needs for persistence, scale, knowledge base, and multimodal data.

This article captures a personal shift in the engineering and founder mindset, charting the transition from writing code line-by-line to orchestrating a specialized "Council of Agents." Drawing from recent hackathon experiences and real-world deployment at ApertureData, it explores how accessible, multimodal tools allow builders to spin up sophisticated systems in hours rather than months. Ultimately, the piece argues that AI doesn't let leaders "tune out" the technical realities or enter an automated hands-off mode. Instead, it elevates the human developer’s role to focus on deep architectural intent, system integration, and production readiness, making agents the next logical evolution in engineering leverage.

Managing subagent personas across multiple AI coding platforms (like Claude Code, Gemini CLI, and Copilot) leads to fragmented configuration files and instruction drift. This article introduces `supagents`, a lightweight, idempotent Python CLI tool that lets developers maintain subagent definitions in a single markdown file with multi-target frontmatter. The tool automatically compiles and distributes these instructions to the correct paths, ensuring a consistent persona across all development environments.

This blog explains how Claude Code Hooks let you automate and control Claude's behavior throughout its lifecycle, turning it from a coding assistant into a programmable part of your engineering workflow. Hooks can run shell commands, call APIs, invoke LLMs, or launch subagents whenever specific events occur.

The blog breaks down human memory into functional layers and maps them to the architectural requirements of AI systems. It shows how separating sensing, storage, context, and reasoning leads to more robust agents, and why today’s embedding‑only approaches fall short.

A walk-through of RePPIT, a five-step framework for shipping production code 2-3x faster with AI that is used by companies of all sizes, from seed-stage startups to public enterprises.

Once agents can use tools, ordinary business content can become part of the control surface. Documents, tickets, webpages, records, and retrieval results may contain instructions the agent should read as data, not follow as commands. Based on a conversation with Pramod Krishnan from PwC, this piece looks at indirect prompt injection, tool permissions, trace review, and why production agents need a clear separation between content and action.

Production agent ROI is usually calculated too narrowly. The model bill is visible, but the bigger cost often sits in reviewer time, eval maintenance, retrieval, storage, platform work, and process change. Based on a conversation with Rani Radhakrishnan from PwC, this piece argues that the real comparison is not headcount saved minus inference spend, but the full cost of the old process against the full cost of the agent-assisted one.

MLOps Community is joining the Linux Foundation as the official user group of the Agentic AI Foundation. The community continues, with more support behind the events, newsletter, podcast, and practitioner conversations.

Subtitle: It’s a feature of the architecture Summary: Hallucination in LLMs is not a data quality problem. It is not a training problem. It is not a problem you can solve with more [RLHF](https://en.wikipedia.org/wiki/Reinforcement_learning_from_human_feedbac), better filtering, or a larger context window. **It is a structural property of what these systems are optimized to do.** I have held this position for months, and the reaction is predictable: researchers working on retrieval augmentation, fine-tuning pipelines, and alignment techniques would prefer a more optimistic framing. I understand why. What has been missing from this argument is geometry. Intuition about objectives and architecture is necessary but not sufficient. We need to open the model and look at what is actually happening inside when a system produces a confident wrong answer. Not at the logits. Not at the attention patterns. At the internal trajectory of the representation itself, layer by layer, from input to output. That is what the work I am presenting here did.

A deep dive into the practical limitations of agent protocols like MCP and A2A for low-level tasks, and why the "Linux philosophy" of using a raw command-line interface provides a more lightweight, composable alternative for local development, paving the way for an Agent OS.

The 5xP Framework is a practical strategy that uses five targeted Markdown files (Product, Platform, Process, Profile, and Principle) to seamlessly align AI coding assistants with your project's architecture and business goals. By defining strict context boundaries, this framework drastically reduces prompt bloat and prevents AI hallucinations, moving developers away from unstructured "vibe coding" and closer to reliable, spec-driven development.

The blog argues that context graphs can serve as the system of record for reasoning, capturing how decisions are made, corrected, and carried forward across humans and AI agents. It shows that making context graphs real requires more than an abstraction: it demands a technical substrate, clear processes, and cultural norms that let organizations review, refine, and preserve judgment over time. When organizations pair emerging context‑graph technology with the cultural shift required to justify decisions, annotate reasoning, and protect shared context, they unlock a future where human and agent judgment reinforce each other, decisions become auditable, knowledge compounds, and the entire company grows more intelligent over time, which is the real trillion‑dollar opportunity.

This blog walks through how to build an AI agent that can meaningfully use a unified collection of multimodal assets like speaker bios, talk titles or descriptions, and eventually their PDF or video content, by pairing the right tools with the right memory design. It demonstrates how retrieval, parsing, and reasoning components must be engineered so the agent can navigate relationships, interpret metadata, and answer higher‑order questions with accuracy.  By grounding the workflow in a multimodal database like ApertureDB, the agent gains reliable access to structured context, enabling richer insights across any real‑world content collection.

The blog shows how to unify scattered multimodal assets, e.g., speaker bios, talk titles, videos, and PDFs. into a single, well‑structured memory layer.  It explains the metadata and schema decisions that let an agent answer richer, cross‑asset questions such as trending topics, influential speakers, or patterns across a full conference.  By grounding these relationships in a multimodal database like ApertureDB, the approach generalizes to any domain where organizations need AI to reason over diverse, real‑world collections of content.

AI coding platforms work best when you treat the AI as a junior engineer, not a replacement for your thinking. Break problems into small tasks, plan in Markdown before coding, and keep your context window lean - accuracy drops sharply past 50% capacity. Never debug in the same chat where you built the feature; the AI is biased by its own logic. For existing codebases, reference well-written code as examples. For new projects, define strict guardrails early - without them, the AI makes hundreds of arbitrary decisions that compound into a mess. The blog dives deep into all the patterns that work, the anti-patterns that silently kill your codebase, and strategies for both brownfield and greenfield projects - each illustrated with detailed diagrams. You stay the architect; the AI executes.

Chaigent combines Chainlit and Vertex AI to deliver a code-first, serverless AI agent platform that avoids costly per-seat licensing fees. It empowers developers to build highly customizable, enterprise-grade agents using a scalable pay-as-you-go architecture.

mAIdAI is a lightweight personal AI assistant built with Google Chat, Cloud Run, and Vertex AI, designed to automate repetitive micro-tasks. By grounding the model with a local markdown context file, it provides highly personalized workflow assistance directly within your chat environment.

This article explores how to use "Agent Skills"—simple Markdown-based context modules—to ensure AI agents strictly adhere to your team's MLOps practices and tooling preferences. By providing explicit organizational rules upfront, developers can eliminate generic boilerplate and align AI-generated code with production-grade standards.

A hands-on beginner roadmap for learning Kubernetes, designed to walk you through core concepts (like clusters, pods, services, deployments, storage, RBAC, autoscaling, etc.) with simple explanations, CLI examples, and practical exercises. By following it you build real experience and are prepared to use Kubernetes locally or on cloud platforms like GKE or EKS.

This post details the practical application of the A2UI protocol, introducing the Agent-View-Controller (AVC) pattern to decouple agent logic from UI rendering. It highlights that while A2UI enables secure, adaptable interfaces, a hybrid architecture combining static and dynamic elements is often required to balance expressiveness with latency.

Addressing the challenge of AI agent exposition, this post evaluates various implementation paths, including full-stack frameworks and AI-generated code. It identifies A2UI as a promising declarative solution that enables dynamic, secure interfaces by decoupling the agent's logic from the client's rendering capabilities.

This blog explains a systematic way to fix CUDA out-of-memory (OOM) errors during GRPO reinforcement learning training, instead of randomly lowering hyperparameters until something works. Subham argues that most GPU memory issues come from three sources: vLLM reserving GPU memory upfront (often the biggest chunk), training activations (which scale with batch size, sequence length, number of generations, and model size), and model memory (usually the smallest contributor). By carefully reading the OOM error message and estimating how memory is distributed across these components, you can identify exactly what’s causing the crash. The recommended approach is to calculate memory usage first, then adjust the highest-impact settings, such as GPU memory allocation for vLLM, number of generations, batch size, and sequence length. The guide also shows how to maintain training quality by using techniques like gradient accumulation instead of simply shrinking everything. Overall, the key message is: treat OOM debugging as a measurable engineering problem, not trial-and-error, so you can fix memory issues faster while preserving training performance.

A system with 70+ automated tools was sending all tool definitions with every query, wasting tokens and slowing responses. The solution was a semantic tool selection system using Redis as a vector database with intelligent embeddings to understand user intent. This approach cut token consumption by 91% while improving accuracy by matching queries to only the relevant tools needed.

Generative AI has evolved at lightning speed from LLMs and RAG to autonomous AI agents capable of reasoning, planning, and acting. But creating a single agent is easy; managing thousands in an enterprise requires a full AI Agent Platform. This guide breaks down the architecture of a production-grade platform, covering layers like Interaction, Development, Core, Foundation, Information, Observability, and Trust. It shows how to build systems that are secure, scalable, and capable of delivering real business impact.