The Video Signal technical video digests

The Gateway provides a single point of control for enforcing spend limits and rate limits across all connected LLM providers, preventing unexpected cost spikes that occur when multiple teams use various keys and models.

Implementing the gateway only requires updating the base URL and API key within existing SDKs (Python, TypeScript), meaning developers do not need to modify their application's core request or response handling logic.

Cost controls can be applied globally for the organization, or granularly by individual API key, user, or workspace. This provides a live audit trail detailing which model, key, and number of tokens were used, replacing reliance on provider invoices.

IBM is teaming up with Together AI to launch an inference cluster on IBM Cloud utilizing NVIDIA's B300 generation chips. This aims to provide cheaper, faster access to open-source AI models for enterprises (1:03).

Meta open-sourced Muse Glimmer, a 30B-parameter dense model optimized to run locally on consumer GPUs (e.g., Mac M3). It is designed for agentic tasks and tool calling without requiring cloud access (11:43).

OpenAI's upcoming Astra model may achieve 'Critical' cybersecurity capability levels, potentially allowing it to find and exploit zero-days. This raises concerns about the speed and scale of cyber warfare using AI (24:10).

The model is positioned as an intelligent 'workhorse' for coding and agents, capable of generating detailed, playable games from initial prompts (e.g., a pizza rush game).

Beyond gaming, the model shows improvements in shipping quality code across debugging, web development, and overall design adherence.

The model successfully generates assets and builds an entire game level (e.g., 90s animated sprite game) from a single prompt within Google Antigravity, demonstrating high design adherence.

The model can adapt an entire game's look and feel to a completely different concept (e.g., changing the theme from sorcerers to a suburban pizza delivery driver) by modifying only a few words in the prompt.

Gemini 3.7 Flash shows improvements across debugging, web development, and overall design adherence, resulting in higher fidelity builds with less back-and-forth iteration.

Policy optimization methods (like TRPO and PPO) define a surrogate objective function to estimate the policy gradient, enabling continuous updates. PPO uses a clipped ratio ($ ext{clip}(r_{ heta}, 1- ext{eps}, 1+ ext{eps})$) to constrain the new policy's divergence from the old one, stabilizing training without requiring complex second-order optimization.

The basic model-based recipe (collect data $ ightarrow$ fit dynamics $P(s'|s, a)$ $ ightarrow$ plan) fails when dealing with complex or nonlinear dynamics because extrapolation outside the observed state distribution is unreliable. This issue of generalization and distribution shift must be addressed.

To improve model-based planning, uncertainty quantification is necessary. The distinction between Aleatoric (inherent noise) and Epistemic (model uncertainty) is crucial. Bayesian approaches treat this by modeling the posterior distribution over parameters ($ heta$), allowing for prediction averaging across all plausible models.

A practical approach to estimate model uncertainty is using ensembles: training multiple independent neural network copies. The average of their predictions approximates the predictive posterior distribution, effectively exploring multimodal solution landscapes without requiring complex analytical derivations.

Monte Carlo methods estimate the expected return ($G_t$) by rolling out an episode until a terminal state, requiring full episodes. Temporal Difference (TD) learning improves upon this by using bootstrapping—defining the target as the instantaneous reward plus the discounted future value ($ ext{Reward} + ext{Discounted Future Value}$), allowing for online updates and handling non-terminal environments.

SARSA is an on-policy algorithm, meaning it improves the policy ($ ext{e.g., } ext{epsilon-greedy}$) that is actively used to generate data in the environment. Q-learning is off-policy; it learns about a target optimal policy (the greedy policy) while using data generated by a different behavior policy (also $ ext{epsilon-greedy}$), which is crucial for utilizing historical or simulated data.

To overcome the curse of dimensionality inherent in tabular value function representations, RL methods transition to parametric functions (e.g., neural networks) that approximate $V(s)$ or $Q(s, a)$. This allows generalization across states and controls.

Deep Q Networks (DQN) stabilize learning using two methods: Experience Replay (storing transitions in a buffer to decorrelate samples, satisfying the IID assumption required for regression) and Fixed Q Targets (using a delayed copy of the network parameters ($ ext{Q}_{ ext{target}}$) to prevent the target from being a moving variable during optimization).

Avoidance sets and reachable sets are computed by solving a differential game using the Hamilton-Jacobi-Isaacs (HJI) equation. This involves reframing the Boolean problem of set membership into an optimal control cost function $h(x)$ [0:35].

To ensure safety over the entire trajectory, not just the endpoint, one must compute a Backward Reachable Tube (BRT). This is achieved by modifying the cost function to minimize the minimum value of $h(x)$ across the entire optimization horizon [7:40].

MPC solves an open-loop optimal control problem over a finite prediction horizon $[t, t+N_p]$ at each time step $t$. It then uses only the first computed input ($u_t$) and discards the rest of the plan, recomputing everything from scratch based on new state measurements (receding horizon) [19:30].

The primary goals when designing an MPC controller are ensuring persistent feasibility (the problem remains solvable at all future times) and guaranteeing stability (convergence to the desired state, e.g., the origin) [36:00].

To guarantee persistent feasibility in MPC, one must identify a control invariant set $\mathcal{C}$. This is a set where, if the system starts within it, there exists a control input $u$ that guarantees the next state remains inside $\mathcal{C}$ [38:00].

Achieving a high prompt cache hit rate is critical for cost-effectiveness. The limit is approximately 15 requests per second (RPS) within OpenAI's cache, and developers must implement strategies to maximize hits, as providers won't solve this distribution problem for you.

Architecturally, Unify treats a subagent not as a complex process, but simply as an arbitrary function call. This simplifies the system and allows for efficient execution patterns like mapping over rows.

Adding an initial planning step (e.g., using GPT-4) to the agent workflow significantly improves quality and efficiency by forcing the model to scout multiple potential trajectories before executing.

To run agents in a cloud environment without full VMs, using specialized tools like Monty (a Python REPL that suspends) is crucial for maintaining statefulness and strong tenancy.

When using an LLM as a judge, it must be from a different model family than the original agent model to avoid 'mode collapse' or groupthink, ensuring an adversarial evaluation.

The model's value must be quantifiable (KPI) and its contribution must outweigh the cost of maintenance. Stakeholders must guide the project scope, preventing engineers from building technically cool but commercially irrelevant solutions.

Proper scoping requires defining who is served (stakeholders/end users), clearly articulating the problem, understanding constraints and risks, identifying possible solutions (MVP approach: crawl, walk, run), and planning maintenance.

Since models are trained on a single point in time, they must be monitored for performance degradation. Strategies include tracking data issues (e.g., distribution changes), feature drift, and model-specific metrics (e.g., Mean Absolute Error, F1 scores).

The system models agents as autonomous entities that perceive the environment and make decisions. The architecture is designed to be observable, attributable, and reproducible through structured world state changes (the 'semantic mirror').

To manage latency, a two-tier vision system is implemented: a fast, deterministic observer swarm (7 Hz) for basic tracking, and a slower, LLM-powered tier using 'Lenses' to extract complex semantic information from the environment.

Key components include the Policy Guard system (defining what agents can/cannot do), the MCP Gateway (Model Context Protocol) for external integration, and a Semantic Cache (Mosquito Dog) to reduce latency and cost by caching LLM responses.

The design ensures determinism through fixed control loops (e.g., 35 ticks per second), state machine transitions, and structured logging of events (JSONL). This allows for full replay and behavioral regression testing.

Despite LLMs showing positive sentiment and high perceived quality (some respondents believe generated code is better than average), a significant portion of developers report low trust in the tool's output, leading to cautious practices like only 8% merging code without human review. This discrepancy suggests a disconnect between perceived capability and actual confidence.

Research indicates that LLM use can impair fundamental learning abilities. Studies found that using LLMs for tasks led to a quantifiable impairment in understanding and debugging unfamiliar codebases, suggesting the tool doesn't just set a bad example but actively hinders skill acquisition.

LLMs are often compared to an inexperienced intern: highly productive, available 24/7, but requiring constant human oversight. The core risk is that junior engineers may not develop the necessary critical judgment skills required to effectively review and correct LLM output.

The process of over-relying on AI can lead to 'cognitive surrender,' where users are willing to follow the machine's incorrect path, even when it is statistically far less likely to be correct. This goes beyond typical automation bias.

The speaker notes that all advancements in AI sit atop the groundwork laid by data science, creating a feedback loop where models inform how data is prepared for future use. (0:15-0:30)

The Data Science periodic table defines five groups across the top (Acquisition, Preparation, Modeling, Generation, Evaluation) and tracks data maturity through rows: Raw Data $\rightarrow$ Prepared Data $\rightarrow$ Model Data $\rightarrow$ Validated Insight. (1:30-2:25)

The AI periodic table features groups like Retrieval and Orchestration, with core primitives including Prompt, Embed, and LLM. Key components include embeddings (encoding info into numbers) and RAG (coordinating retrieval). (2:35-3:40)

Building a system requires combining elements from both tables. The process moves linearly through data preparation (ET $\rightarrow$ DI $\rightarrow$ CD $\rightarrow$ ST $\rightarrow$ EN $\rightarrow$ GO) and then AI processing (EM $\rightarrow$ Vx $\rightarrow$ RAG $\rightarrow$ PR $\rightarrow$ LG $\rightarrow$ GR). (4:30-6:20)

To prevent the system from being a one-way street, the pipeline is closed using Data Drift (DR) detection and Synthetic Data generation. This allows the embedding model to fine-tune itself continuously based on failing patterns. (6:40-7:50)

Production agents introduce three main pressure points: Cost (unpredictable spend from looping/context growth), Reliability (need for fallbacks and clear failure behavior), and Compliance (consistent policy enforcement required by regulated industries).

Governance must be implemented as a central infrastructure layer, rather than being bolted on application-by-application. This centralized approach manages interactions with external services (LLMs, tools) and ensures visibility across the entire system.

Governance controls must cover four distinct interaction points: LLM calls (cost/data risk), Tool calls (unintended actions/permissioning), MCP calls (data leaving infrastructure), and Agent-to-Agent calls (identity and compounding errors).

For regulated industries, governance must address specific regulations like GDPR, CCPA, HIPAA, and the EU AI Act. This involves implementing guardrails for PII/secrets detection, role definition, and audit logging.

The state update is modeled as $x_{k+1} = f(x_k, u_k, w_k)$, where $w_k$ is a random disturbance. The system must adhere to the Markovian assumption: the probability distribution of $w_k$ can only depend on the current state ($x_k$) and control ($u_k$), not on the history of previous states or disturbances.

The notion of optimality is defined by minimizing the expected cost, $\mathbb{E}[ ext{Cost}]$, over all possible disturbance realizations. The solution uses a backward dynamic programming recursion (Bellman equation) to find the optimal closed-loop policy $\pi^*$.

To solve problems over an infinite number of stages, a discount factor ($\gamma \in [0, 1]$) is introduced to ensure the convergence of the expected cumulative reward. The optimal value function $V^*$ satisfies a fixed-point equation: $V^*(x) = \max_{u} \{ R(x, u) + \gamma \mathbb{E}[V^*(x')]\}$.

For computational tractability in learning settings where the transition kernel is unknown, the problem can be reformulated using the Q-function ($Q^*$), which represents the expected cumulative reward starting at state $x$ and taking action $u$, followed by optimal actions: $Q^*(x, u) = R(x, u) + \gamma \sum_{x'} T(x'|x, u) V^*(x')$.

While LQR is fundamentally designed to drive a state to the origin (regulation), it can be generalized to perform trajectory tracking by defining an auxiliary problem based on deviation variables. The optimal control law structure remains consistent: $u = u_{nominal} + ext{feedback term}$.

For nonlinear dynamics ($x_{k+1} = f(x_k, u_k)$), the tracking problem can be linearized by performing a Taylor expansion around the nominal trajectory ($\bar{x}, \bar{u}$), allowing the use of LQR techniques on the deviation variables.

Both iLQR and DDP are methods for solving nonlinear optimal control problems iteratively. iLQR linearizes dynamics and quadratizes costs, while DDP directly approximates the Bellman equation by quadratizing the Q-function, making it a second-order algorithm in terms of dynamic derivatives.

To gather data for improvement, an agent must be deployed into a real-world environment (shipping it). This process generates valuable trace data from tool calls, API usage, and CLIs.

There is a tight coupling between observability and continual learning for agents. Both require comprehensive traces—the record of actions taken in the environment—to allow the agent to update its internal knowledge or definition.

Traces capture fine-grained behavior that simple pass/fail benchmarks miss. They are crucial for proving counterfactuals (e.g., comparing GPT 5.5 vs. GLM 5.2) and understanding how agents behave at a granular level.

For agent improvement, the recommended loop is: Start with Harness Engineering (fast feedback, ~2 minutes) $\rightarrow$ Saturate this ceiling $\rightarrow$ Fine-tune the model to break through it $\rightarrow$ Return to Harness Engineering.

Agent activity will generate data at an exponential rate, potentially eclipsing all human-produced data in history. Managing this requires building systems that can efficiently mine and process traces.

There is no single way to implement AI memory; products evolve independently (e.g., ChatGPT uses dense keywords/running profile; Claude uses full sentences/tools).

A running profile requires balancing two costs: the cost to maintain (update frequency/compute) and the serving cost (profile length in context window). This trade-off dictates product design.

The biggest limitation of current AI memory systems is not technology, but product design. They often fail to reason over rich external sources like emails or calendars, leading to conflicts (e.g., conflicting travel dates).

The process begins by installing dependencies using `UV tool install managed deep agents` and initializing the project with `MDA init social post assistant`. The agent's entry point (`agent.py`) is configured, specifying model properties (e.g., changing to `GPT-5.6 Luna` for cost efficiency) and defining access tools.

Custom tools are built to interact with external APIs: a tool to search Hacker News (using Algolia API) and two tools for X/Twitter (`get X user timeline` and `search X posts`). Authentication requires defining bearer tokens in the `.env` file.

The agent's behavior is governed by a core instruction file (`instructions.md`) and specialized, modular knowledge packages called 'Skills.' A skill (e.g., `draft posts`) provides dynamic instructions for specific tasks like drafting or revising content.

To maintain context across different runs, a memory file (`memory.py`) is set with the scope to 'agent.' The agent's autonomy is established by creating a schedule (e.g., `morning drafts.py`) using cron expressions to run daily at 9:00 a.m. Pacific time.

The agent is tested locally via `MDA dev` (which opens the agent in LangSmith Studio) before deployment using `MDA deploy`. Slack integration requires running `mda channel add slack`, generating a manifest, and setting up necessary environment variables (Slack signing secret and bot token).

The most critical concern for agents is not their maximum capability (the ceiling), but their worst-case behavior (the floor). The floor represents failures that break user trust, such as accidental data deletion or sending inappropriate communications.

Evaluation suites should be implemented as code (like unit or end-to-end tests) rather than relying on managed prompt playgrounds. This approach is necessary because the underlying structure of agents and their tools has fundamentally changed.

When tracking issues, knowing only that an issue exists is insufficient. It is critical to track two metrics: when the issue started (to identify recent changes) and what percentage of users are affected.

1. **Clusters are not issues:** Clustering traces is useful for one-off analysis but does not scale well or reliably track changes over time. 2. **Code Mode Scaling:** Apply code mode concepts to traces by writing classifiers and running them in a sandbox at production volume. 3. **Anomaly Investigation:** Agents are poor at detecting anomalies, so instead, surface deterministic signals (like keyword spikes) for the agent to investigate.

Continual learning can be approached across four quadrants defined by trace type (Offline/Online) and hint source (Static/Dynamic). The most scalable method is Quadrant 4: Online hints paired with online production traces, enabling continuous improvement as the model serves live traffic.

The framework emphasizes improving agents without requiring a 'golden answer' or perfect rubric. This approach allows for targeted behavior changes (e.g., encouraging tool calls) by conditioning the rollout on existing production traces and injecting hints, rather than forcing specific tokens.

In a fully online setting, dynamic hints based on the model's own recent rollout can dramatically improve highly specialized behaviors (e.g., correct hyperlink formatting), raising performance from 15% to 80%, significantly outperforming static offline hinting methods.