The Video Signal

Topic

Microservices Architecture

All digests tagged Microservices Architecture

Aspire 13: One AppHost, Many Languages, Fewer Headaches? - Chris Ayers - NDC Toronto 2026 thumbnail

· 52:34

Aspire 13: One AppHost, Many Languages, Fewer Headaches? - Chris Ayers - NDC Toronto 2026

Aspire AppHost provides a unified orchestration layer for polyglot systems, allowing developers to treat mixed-stack projects (e.g., .NET API, Python worker, Node front end) as a single product rather than multiple disconnected repositories. The system simplifies local development by automating service wiring, managing configuration via environment variables, and providing a centralized dashboard for unified telemetry, logging, and debugging across diverse languages.

Key takeaways

  1. Unified Polyglot Orchestration 2:00

    Aspire AppHost allows developers to declare services, dependencies, and resources in one place, eliminating the need for scattered configuration files (YAML, appsettings.json) and complex manual setup scripts.

  2. Centralized Observability 3:30

    The dashboard provides a single pane of glass to view telemetry, structured logs, traces, and metrics from all connected services, greatly simplifying debugging across different language stacks.

  3. Automated Service Wiring & Discovery 5:40

    Service discovery is handled automatically using conventions (e.g., `services_` or `connections_`), ensuring that services can find and connect to dependencies (like databases) without manual IP/port configuration.

  4. AI-Assisted Development Workflow 9:40

    New agent capabilities allow developers to manage environments, query logs, debug failures, and even suggest code fixes directly within the chat interface (e.g., using VS Code Copilot).

Watch on YouTube Full article

AI-Native Organisations Run on Skills: How to Structure and Scale Them — Imad Touil, QuantumBlack thumbnail

· 20:31

AI-Native Organisations Run on Skills: How to Structure and Scale Them — Imad Touil, QuantumBlack

The talk argues that in AI-native organizations, organizational know-how resides primarily within 'skills.' While skills offer deterministic outcomes for complex workflows, ungoverned skills quickly accumulate as a form of technical debt due to duplication and quality decay. To scale effectively, organizations must adopt governance principles—borrowing from the microservices era—by implementing a centralized skills platform that provides metadata, search, versioning, access control, and clear ownership.

Key takeaways

  1. Skills are the core of organizational know-how 11:43

    The agentic software stack relies heavily on 'skills' (the deterministic component) within its outer workflow loop. If skills are unstructured, the resulting workflow is not truly deterministic.

  2. Governance prevents technical debt 20:30

    Without governance, teams repeatedly build similar skills (duplication), quality degrades because skills aren't retested against new models, and ownership is unclear. This creates a new class of technical debt.

  3. A centralized platform is mandatory for scale

    Scaling requires a central skills catalog with metadata, dependency mapping, versioning (to pull the current release), access control, and named human owners across architecture, infrastructure, and security.

Watch on YouTube Full article

Unlock Agent Autonomy: The Runtime for AI-Native Systems — Tushar Jain, Docker thumbnail

· 22:50

Unlock Agent Autonomy: The Runtime for AI-Native Systems — Tushar Jain, Docker

The talk addresses the critical shift from making AI agents more intelligent to making them safer and more autonomous. The core challenge is that as agents investigate complex issues (like latency spikes), their required access expands at runtime, significantly widening the 'blast radius.' The speaker proposes a new runtime layer designed to manage this complexity by enforcing three pillars: **Containment** (running the agent in an untrusted boundary while controls remain outside), **Scoped Capabilities** (providing only the minimum necessary access for a specific task), and **Intent-Based Access** (determining if the requested action aligns with the original user intent). This runtime must be portable across all environments (local, cloud, VPC) and models.

Key takeaways

  1. The Shift from Intelligence to Safety

    The next major challenge in agent development is not intelligence, but safety. Traditional software had fixed permissions; autonomous agents change their required access at runtime, necessitating a fundamental shift in security architecture.

  2. The Danger of Expanding Scope 5:12

    When an agent investigates a problem (e.g., latency spike), it sequentially requests access to logs, GitHub history, and Slack. Each step expands the trust boundary, leading to a single process with excessive, accumulated permissions.

  3. The Three Pillars of Safe Autonomy 10:24

    A proposed runtime layer must implement: 1) **Containment** (controls outside the agent's boundary); 2) **Scoped Capabilities** (providing granular access per task, not accumulating them); and 3) **Intent-Based Access** (validating if a sudden request—like email access during an incident investigation—is correct or should be escalated).

  4. Portability and Orchestration 22:38

    The runtime must be omnipresent, working across different models (Anthropic, Claude, Open Code), multiple harnesses, and environments (local machine, cloud VPC). The speaker demonstrated that the same secure sandbox can run locally or in the cloud, and these sandboxes can be composed for parallel execution and orchestration.

Watch on YouTube Full article

The Last Human Code Review: Building Trust in AI-Generated Code — Itamar Friedman, Qodo thumbnail

· 18:54

The Last Human Code Review: Building Trust in AI-Generated Code — Itamar Friedman, Qodo

The bottleneck in modern software development is shifting from writing code to managing governance and context within the Software Development Life Cycle (SDLC). The speaker argues that AI models are no longer the primary constraint; instead, the critical challenge is codifying 'tribal knowledge'—the undocumented best practices, architectural contracts, and historical failure data held by senior developers. Future code review must transition from line-by-line diff checking to reviewing a comprehensive software graph that tracks inter-service dependencies and potential contract breaks across multiple concurrent Pull Requests (PRs).

Key takeaways

  1. The Bottleneck Shift

    The primary bottleneck is no longer writing code, but rather the governance layer within the SDLC. Organizations must address how to automate or enhance code review processes that validate architectural standards and business intent.

  2. Two Competing Philosophies 5:38

    Engineering leaders are split into two camps: those who insist every line of code requires human trust/review, and those who prioritize velocity by shipping bugs quickly and fixing them post-deployment. The chosen philosophy dictates the necessary tooling and governance strategy.

  3. Context is the Constraint 8:39

    The limitation is not model reasoning ability; it is the scattered nature of context—which resides across competing instruction files, internal team standards, and undocumented knowledge held in developers' heads or Slack threads. Codifying this context is paramount.

Watch on YouTube Full article

Managed Deep Agents explained in 20 minutes thumbnail

· 18:17

Managed Deep Agents explained in 20 minutes

Managed Deep Agents provides an integrated framework to simplify the entire lifecycle of building, running, and deploying AI agents into production. It addresses the complexity of agent infrastructure by bundling the open-source Deep Agents harness with necessary components like durable execution, context management (via Context Hub), sandboxes, and scheduling capabilities, allowing developers to move from local business logic directly to a scalable, managed deployment on LangSmith.

Key takeaways

  1. Agent Architecture Components

    An agent requires three layers: 1) Business Logic (provided by the user, e.g., prompts/tools); 2) Harness (orchestrates context and passes data to the model); and 3) Infrastructure (runtime, sandboxes, etc.). Managed Deep Agents bundles these into a seamless package.

  2. Production Readiness 2:05

    The framework handles complex production requirements such as durable execution, fault tolerance, streaming, queueing, run cancellation, and rollbacks, which are necessary when moving agents from local development to cloud serving.

  3. Decoupled Context Management 5:05

    Context (instructions and skills) is stored in the dedicated Context Hub. This allows non-developers to edit and maintain agent context via a UI without requiring code changes or redeployments, significantly improving collaboration.

  4. Deployment Workflow 10:30

    The process involves initializing the project using `MDA innit research assistant`, defining components (e.g., tools in `tools/search.py`), and deploying via `MDA deploy`. This pushes context to Context Hub and creates a deployment on LangSmith.

Watch on YouTube Full article

Let's integrate AI Agents in Event-Sourced Systems — Divakar Kumar, FlyersSoft thumbnail

· 21:37

Let's integrate AI Agents in Event-Sourced Systems — Divakar Kumar, FlyersSoft

The presentation outlines an advanced architectural pattern for integrating AI agents into existing enterprise systems, specifically targeting real-time fraud detection. Instead of replacing established Rule-Based Engines or ML models, the approach layers agentic intelligence to resolve 'gray zone' transactions—cases where current deterministic systems lack sufficient context. The architecture leverages Event Sourcing and Domain-Driven Design (DDD) principles by building a centralized semantic layer that aggregates data from multiple bounded contexts (e.g., Transaction, Device, Account). Agents then consume this enriched context via an orchestration layer in a saga pattern to reach a final verdict.

Key takeaways

  1. AI Agents Augment, Not Replace, Existing Systems

    The primary value of AI agents is not replacing existing systems (like rule-based or ML engines) but rather adding an agentic layer to handle ambiguous cases—the 'gray zone' where current models lack necessary context. The goal is to enhance business workflows using the state and history already captured by event sourcing.

  2. Context Aggregation via Semantic Layer 17:37

    To provide sufficient context for agents, data from disparate bounded contexts (Transaction, Device, Account, Payment) must be aggregated into a semantic layer or materialized view. This is achieved by propagating domain events using Change Data Capture (CDC) mechanisms or message brokers.

  3. Saga Orchestration and Agentic Decision Making

    The system uses an orchestration layer to manage the process. This layer employs a fan-out pattern, sending events simultaneously to multiple specialized agents (e.g., Risk Analyzer Agent, Behavior Analyzer Agent). A final Verdict Agent then analyzes these responses to reach a consensus event.

Watch on YouTube Full article

Introducing the SQL MCP Server - Jerry Nixon - NDC Toronto 2026 thumbnail

· 55:44

Introducing the SQL MCP Server - Jerry Nixon - NDC Toronto 2026

SQL MCP Server, an open-source component from Microsoft's data API builder, provides a secure and standardized abstraction layer for modern applications, especially those powered by AI agents. It allows external models to interact with enterprise databases (including SQL Server, PostgreSQL, Cosmos DB, and MySQL) without requiring direct T-SQL knowledge or exposing sensitive connection strings. The solution standardizes database access into three endpoints—REST, GraphQL, and MCP—simplifying the development process and significantly enhancing security by enforcing policies at the API layer.

Key takeaways

  1. Unified Data Access Layer 2:00

    The SQL MCP Server acts as a single point of entry for all data interactions, supporting multiple database types (SQL, NoSQL) and exposing three standardized APIs: REST, GraphQL, and the specialized Model Control Protocol (MCP). This abstraction layer allows developers to write code against the API surface rather than directly against the underlying schema.

  2. AI Agent Integration via MCP 8:00

    For AI agents, which cannot speak directly to a database, the MCP endpoint is critical. It collapses the potential hundreds of CRUD tools (one per table) into a standardized set of seven tools (Describe Entities, Create, Read, Update, Delete, etc.), preventing model overload and ensuring reliable agentic workflows.

  3. Simplified Development & CI/CD 3:00

    The solution aims to eliminate the need for boilerplate CRUD API code in a codebase. By using data API builder, developers can significantly reduce complexity and potential errors, streamlining the CI/CD pipeline while maintaining high functionality.

  4. Advanced Security & Policy Enforcement 10:50

    Security policies (like Row-Level Security) can be enforced at the API layer, even if structural changes are impossible in the underlying database. Furthermore, it supports advanced authentication methods like OpenID Connect and On Behalf Of (OBO) pass-through authentication.

Watch on YouTube Full article

The Best AI Automation Stack to Learn in 2026 thumbnail

· 16:33

The Best AI Automation Stack to Learn in 2026

The video outlines a comprehensive five-layer stack for building production-ready AI automation and engineering solutions. The recommended architecture emphasizes foundational software engineering principles—backend, database, frontend, AI models, and infrastructure—rather than relying solely on high-level no-code tools. Core technologies include Python/FastAPI/Celery for the backend, Postgres/Supabase for data storage, React/Vite/ShadCN UI for the frontend, and cloud providers (AWS, Azure, GCP) or specialized services for model integration and deployment.

Key takeaways

  1. Focus on Foundational Layers

    To build a career in AI engineering, understanding how to integrate core components—backend, database, frontend, AI layer, and infrastructure—is more valuable than mastering specific high-level tools.

  2. Backend Core Stack

    Python is the recommended language. FastAPI serves as the API entry point (handling GET/POST/PUT/DELETE webhooks), while Celery manages background workers and scheduled cron jobs, ensuring robustness and scalability.

  3. Database Recommendation 7:15

    Postgres is recommended as the primary database layer. Supabase is suggested as a wrapper around Postgres that simplifies authentication and provides an out-of-the-box admin GUI.

  4. Frontend Stack 12:00

    The recommended frontend stack is React (industry standard UI library), Vite (development server/bundler), and ShadCN UI (a component library for rapid, customizable development).

  5. Deployment Strategy

    For custom deployments, the industry standard is using Docker. For ease of use, platforms like Railway are recommended to simplify deployment setup (e.g., deploying FastAPI/Celery and React code). Advanced options include container services from major cloud providers or dedicated VPS hosting.

Watch on YouTube Full article