Loading…
Browse by type
Tutorial reads
Tutorial posts on Yomu, summarised newest first.
- 615 posts
- 20 companies
The Good Stuff
Paid picks we use ourselves. Links carry a referral code — a subscription through one earns us a commission at no extra cost to you.
Tutorial posts
How To Set Up a Staging Environment on Heroku in 3 Easy Steps
The guide explains how to add a Heroku staging environment so changes are tested in a near-identical, isolated replica before production. It uses a pipeline with production and staging apps, disables production automatic deployments, connects staging to GitHub, and enables automatic builds, with Review Apps offered for pull requests. The setup applies Twelve-Factor practices by separating config vars and databases, recommending migrations into a fresh Postgres database or warning that pg:copy overwrites staging data and can create compliance risks. After validation, slug promotion sends the exact compiled staging asset to production without recompiling, while numbered releases support rollback; database changes must still be reversed separately.
What happens in the milliseconds after you tap pay
At checkout, fraud scoring must combine transaction inference with customer-specific rules while keeping latency low enough for an interactive payment. The retail-app sample pairs a FastAPI backend and React frontend in a Databricks App with Model Serving route optimization and Lakebase Postgres, where the model retrieves historical features and the backend reads profile controls. A transaction is scored first, then checked against daily spending, international-transaction, and country rules; pooled OAuth-authenticated connections and token-rotation handling avoid repeated handshakes and stale credentials. In the supplied benchmark, route-optimized calls reached 27.2 ms p50 and 37.3 ms p95 end-to-end, with feature lookup at 8.9 ms p50, CatBoost inference at 0.4 ms, and network overhead at 17.4 ms p50; actual performance varies by model.
Build a Secure C# MCP App with Cross App Access (XAA)
Cross App Access (XAA) addresses the gap between a user’s authenticated identity and a downstream MCP server, API, or agent tool that must trust that identity without another login. The described flow uses OIDC and PKCE for sign-in, then RFC 8693 token exchange to turn the ID token into a JWT Authorization Grant (JAG), followed by RFC 7523 exchange at the MCP authorization server for a scoped bearer token. A C# MCP SDK IdentityAssertionGrantProvider encapsulates both exchanges, while ASP.NET Core OIDC middleware persists the ID token and an HTTP transport presents the resulting token to the MCP server. The sample connects to a Todo resource through the xaa.dev playground, completes MCP initialization, lists resources, and reads todo0://todos; the article states that the end-to-end implementation fits in under 50 lines of C#.
How to Run an Autoresearch Workflow with RL Agent Skills and NVIDIA NeMo
Setting up reinforcement learning workflows and running repetitive experimentation often consumes significant engineering time before meaningful metrics emerge. To address this, an autonomous autoresearch workflow uses a frontier coding agent running Codex with GPT 5.5 to manage NVIDIA NeMo RL and NeMo Gym on an NVIDIA Brev GPU instance. The agent executes full-stack setup, creates a novel NeMo Gym visual counting environment, tunes Qwen3-VL-2B-Instruct accuracy from 25.0% to 96.9%, and implements an off-policy reinforcement learning algorithm directly from a research paper. Reusable skills, including brev-etiquette, session-memory, and autoresearch, enforce local conventions and prevent context drift during long executions. This setup offloads environment configuration, dependency resolution, and experiment tracking while preserving human oversight for goals and strategy.
Post-Train NVIDIA Cosmos 3 in One Day Using Agent Skills
Adapting vision reasoning models for specialized physical AI video tasks often demands days of manual container configuration, training script authoring, and hyperparameter tuning. NVIDIA Cosmos 3 Nano, an omnimodal mixture-of-transformers model, pairs an autoregressive Reasoner tower with an iterative diffusion Generator tower for video question answering. By integrating NVIDIA TAO agent skills with a coding agent like Codex, developers can automate data patching, evaluation, and Low-Rank Adaptation (LoRA) post-training. In experiments using the Woven Traffic Safety dataset, LoRA fine-tuning boosted zero-shot baseline accuracy from 54.41% to 87.14% while using approximately seven times fewer GPU hours than full-parameter supervised fine-tuning. Combining this agent workflow with TAO AutoML further elevated model accuracy to 93.35% before automated deployment via NVIDIA NIM.
How we configure huge pages in ClickHouse Managed Postgres
ClickHouse Managed Postgres configures Linux huge pages to reduce the per-connection page-table cost and translation overhead of a large PostgreSQL shared_buffers cache. The configuration reserves a quarter of machine memory before PostgreSQL starts, verifies HugePages_Total, sets huge_pages = 'on' to prevent silent fallback, and sizes shared_buffers against the complete shared-memory segment, including buffer descriptors, WAL buffers, and lock tables. On an r7i.4xlarge with 32GB shared_buffers, 4KB pages added 31.1MB of page tables per connection and reached 6.12GB at 200 connections, while 2MB huge pages reached 111MB. A select-only pgbench test at 100 clients also rose from 373,083 TPS to 418,087 TPS, a 12% increase, while startup failure without a sufficient pool made misconfiguration explicit.
Create a LangChain Deep Agents Harness Profile for NVIDIA Nemotron 3 Ultra to Improve Performance
The tutorial shows how to create and validate a LangChain Deep Agents harness profile for NVIDIA Nemotron 3 Ultra using an evaluation benchmark rather than fine-tuning the model. It starts with a baseline, analyzes failed trajectories, and iterates on prompts, exclusions, or added middleware while rerunning tests to detect regressions. One failure occurred when read_file returned the first page of a large file without signaling that more content existed, so the model answered before paginating to the line containing opal-fox-91. The proposed ReadFileContinuationNoticeMiddleware appends a continuation notice when a full page is returned, raising the reported benchmark score from 94/127 to 96/127 and resolving all three read_file tests. The source also describes automating this propose, verify, and retain-or-reject loop, with safeguards against overfitting and regressions.
We terminated a TPU mid-training and it recovered in seconds: Introduction to elastic training with MaxText
Distributed training on multiple TPU machines normally fails as a whole when one worker disappears: collective communication times out, processes exit, and the job restarts from a checkpoint. The article demonstrates elastic training with JAX, MaxText, PathwayS, Orbax, and Cloud TPUs on GKE, using a single CPU-side controller that remains alive while TPU workers execute compiled programs. A Pathways elastic_retry wrapper catches the failure, cleans up partial state, restores the last viable checkpoint, and re-enters the training function without relaunching the workload; the demo returned to training in under two minutes, with no JobSet restarts, after losing 88 steps. It also contrasts pause-and-resume with replica resize, explains direct checkpoint persistence through ENABLE_PATHWAYS_PERSISTENCE=1, and describes planned snapshot-based recovery from host memory.
How to Build and List Secure Cross App Access (XAA) Connections on Okta Integration Network (OIN)
Cross App Access (XAA) provides an identity framework for securing token-based communication when software or AI agents access external ecosystems through trusted identity providers. It replaces long-lived API keys and hardcoded secrets with real-time identity propagation, while allowing enterprises to control connected apps, requested scopes, and user access. The guide explains prerequisites for requesting and resource apps, including OIDC or SAML SSO, authorization-server support, protected resources, scopes, an Okta Integrator Free Plan org, and tested workflows. It then describes token exchange testing: requesting apps obtain an ID token and mint an ID-JAG, while resource apps validate the ID-JAG and issue a scoped access token. To seek OIN listing and XAA enablement, applicants submit SSO integration details, metadata, testing evidence, and a questionnaire to Okta.
Enabling Cross App Access for SAML-Based Resource Apps
Cross App Access (XAA) lets applications using existing SAML federation obtain API access without migrating to OpenID Connect (OIDC). An agent presents a short-lived Identity Assertion Authorization Grant (ID-JAG), which the resource authorization server validates, resolves to a user, and exchanges for its own access token; SAML processing remains upstream. For SAML identity resolution, implementations must validate the saml-nameid sub_id and match issuer, NameID, and sp_name_qualifier rather than relying on NameID alone. The guide recommends binding iss to a registered SAML connection before verifying the JWT against that connection’s JWKS, then checking typ, aud, and client_id and applying local scope policy. It also walks through Okta configuration and xaa.dev checks that redeem the ID-JAG, call the API, and export conformance results.
Granular Usage Attribution for dbt Pipelines with Query Tags
Databricks Query Tags give dbt pipelines granular usage attribution when identical query-history rows obscure model ownership, cost, and performance. The dbt-databricks adapter version 1.11+ automatically injects model, materialization, dbt-core, and adapter-version metadata, while profile-level and model-level configurations add custom dimensions such as team, cost center, project, and environment. These tags are stored as a MAP<STRING, STRING> in system.query.history, where SQL can extract them for cost attribution, performance debugging, monitoring, and dashboards. In the reference project, four mart tables accounted for 92% of compute time, whereas staging views and metric views were near-instantaneous. The accompanying open-source project demonstrates Genie exploration, a self-monitoring AI/BI dashboard, metric-view tagging, and deployment with Databricks bundles, while recommending consistent profile hierarchies, environment tags, and limited custom metadata.
Mastering Agentic Techniques: AI Agent Reinforcement Learning
Language model agents often fail across long-horizon workflows, repeat tool-call errors, and output invalid schemas when relying solely on prompting or retrieval. Reinforcement learning with verifiable rewards provides a practical training signal for domain-specific tasks by scoring model rollouts against deterministic verifiers such as schema checkers, unit tests, and execution sandboxes. Teams can implement group relative policy optimization to sample multiple trajectories per prompt and update policy weights based on relative performance within the group. Establishing environments with explicit harness, state, and verifier definitions allows agents to learn multi-step tool use, whereas static datasets fail to capture sequential dependencies. Inspecting checkpoint rollouts and testing against held-out tasks prevents reward hacking while continuously turning operational failures into verifiable benchmark environments.
Driving the Agent Quality Flywheel from Your Coding Agent
The quality-flywheel skill addresses the gap between prompt tweaks that improve a few examples and evidence that an agent improved without regressions. A coding agent orchestrates dataset preparation, inference, trace grading, failure analysis, and optimization, using Google's adaptive AutoRaters or custom metrics while keeping the optimizer and evaluator independent. In a travel-concierge example, the revision_honored rubric found that 21% of cases ignored mid-conversation trip changes, exceeding the stated action threshold. A separate software-bug-assistant cycle raised tool-disclosure responses from 0% to 96% across 15 cases, while production traces and online monitors extend the same loop beyond synthetic scenarios. Human approval remains required, and adaptive scores are treated as directional signals rather than absolute grades.
Next.js already traces your requests. Here's how to export them with OpenTelemetry.
Next.js provides out-of-the-box tracing for incoming requests, fetch calls, middleware, and server-side rendering, but traces remain invisible without a configured exporter. Developers can use the @vercel/otel package inside an instrumentation file to initialize the OpenTelemetry SDK and transmit traces to any OTLP-compatible destination. While Next.js automatically creates spans for standard request lifecycles, developers can define custom active spans in the Node runtime to capture specific domain operations and contextual attributes. Exporting traces to backends like Sentry requires configuring standard OTLP endpoint and authentication environment variables. Choosing between direct OTLP export via @vercel/otel and the dedicated Sentry SDK depends on requirements, as direct export lacks browser tracing, error monitoring, and Edge custom spans.
Deploy a Production-Ready NVIDIA AI-Q Blueprint on Oracle Cloud Infrastructure
The NVIDIA AI-Q Blueprint operates as an open-source reference architecture for long-horizon agents built upon LangChain Deep Agents and the NVIDIA NeMo Agent Toolkit. Deploying this multi-agent system on Oracle Cloud Infrastructure requires coordinating foundational cloud infrastructure with containerized application workloads across Kubernetes. The deployment methodology utilizes Terraform to provision network isolation, an enhanced OKE cluster, a flexible public load balancer, and an AES-256 encrypted OCI Vault. Helm manages the application layer on Kubernetes by pulling official images from the NGC registry to run a FastAPI agent backend, a Next.js web frontend, and PostgreSQL. This configuration establishes an extensible routing architecture where user queries route automatically between shallow search agents and deep planning sub-agents while maintaining clean infrastructure teardown commands.
The new product introduction process: How to make sure your Agent is ready every time you ship
Frequent product releases can leave an AI Agent’s knowledge base outdated, causing it to hand off launch-related questions to humans when support volume peaks. The NPI process described here makes Agent readiness part of shipping, with support involved early in product, engineering, and go-to-market planning. Before launch, teams prepare clear customer-language content with full context, review and retire affected or duplicate material, then test likely questions, edge cases, and answer quality in the customer environment. At Fin, release details, walkthrough notes, demos, and GTM briefs form an input package for Operator, which proposes content updates, drafts, FAQ tests, and fixes. Post-launch Monitors and Scorecards track resolution rate and CX Score for two or four weeks, depending on launch complexity, to guide improvements.
How I hunt for vulnerabilities with AI
The author describes using AI-assisted code review to hunt for vulnerabilities in ClickHouse, a large C++ codebase, despite having limited bug-bounty experience. GitHub Copilot, Claude, ChatGPT, and Gemini models were used to inspect code, generate vulnerability hypotheses, explain unfamiliar subsystems, and identify older or newly introduced attack surfaces. Promising ideas were recorded, then investigated with Python scripts against a locally running ClickHouse Docker container, followed by manual review and reproduction to distinguish genuine findings from hallucinations and misconfigurations. The work produced a few real vulnerabilities that were reported to ClickHouse’s security team and bug bounty program, while the broader conclusion is that AI can accelerate exploration and validation but still requires persistent questioning and human verification.
Scaling AI Inference Across Multiple GPUs Using NVIDIA TensorRT with Multi-Device Inference Support
Generative AI media pipelines can exceed the memory and compute capacity of a single GPU, creating a deployment challenge for models that retain TensorRT’s kernel fusions, memory planning, and quantization. TensorRT 11.0 introduces native multi-device inference and IDistCollectiveLayer primitives, while NCCL supplies topology-aware transport across NVLink, NVSwitch, PCIe, and InfiniBand for supported distributed collectives. The article contrasts tensor parallelism, which shards layer weights, with context parallelism, which partitions sequences; it then focuses on AllGather KV, Ring Attention, and DeepSpeed Ulysses for long-sequence media attention. It also describes converting PyTorch pipelines with Torch-TensorRT into C++-deployable engines, benchmarking Cosmos 3 and FLUX.1 on an eight-GPU node, and provides C++ and OpenMPI steps for configuring an eight-rank NCCL deployment.
A 15-Second Health Check for Your Heroku Connect Data Pipeline
Heroku Connect’s built-in CLI diagnostic utility addresses troubleshooting when Salesforce records lag or fields fail to update as expected, replacing manual dashboard searches with a focused health check. After installing the Heroku Connect CLI plugin, engineers can run heroku connect:diagnose --verbose to inspect connection-level settings and mapping or field configurations. The output reports sequential GREEN, YELLOW, RED, or SKIPPED statuses, with checks covering Salesforce API version, permissions, database plan, schema changes, field types, unique identifiers, and other constraints. Examples include an outdated API version, missing View All Data or Modify All Data permissions, binary or calculated fields, and Salesforce or Postgres schema drift; the text pairs these warnings with actions such as recreating or refreshing a connection, removing binary fields, or realigning mappings. Running the command before migrations or Salesforce schema changes provides an immediate view of configuration mismatches and sync bottlenecks.
Build an AI Scientist for Life Science Discovery with NVIDIA BioNeMo Agent Toolkit
General-purpose AI agents often struggle with biomolecular discovery because scientific workflows require precise model selection, strict input formatting, and artifact interpretation. The NVIDIA BioNeMo Agent Toolkit bridges this gap by providing BioNeMo Skills and Model Context Protocol wrappers on top of accelerated NVIDIA NIM microservices. These skills instruct agents on tool capabilities, required inputs, expected file formats like CIF and SMILES, and specific failure modes. Developers can route requests through hosted endpoints for testing or deploy local NIM microservices on GPU nodes to lower warm per-call latency during iterative candidate generation loops. Internal benchmarks using Codex CLI demonstrate that equipping agents with BioNeMo Skills improves task completion rates from 57.1% to 100% while doubling token efficiency across passing assertions.
Top topics
- Architecture830
- Performance812
- LLMs648
- Machine Learning617
- Open Source561
- AI Agents542
- AI454
- Developer Experience446
Weekly digest
The best engineering reads, once a week.