Pi agent is open-source and highly customizable, allowing engineers to modify the agent harness, UI (down to font color), and behavior through extensions.

The Pi Coding Agent: The ONLY REAL Claude Code COMPETITOR

Provides greater control and flexibility for advanced engineers who want to tailor their agentic coding experience.

Explore Pi agent's extension system and customization options to create a personalized agentic coding environment.


Pi agent prioritizes minimal system prompts (200 tokens) and allows the model to 'cook,' focusing on thinking, reasoning, and problem-solving, contrasting with Claude Code's 10,000-token prompt with baked-in best practices.

Offers a different approach to agent prompting, potentially leading to more creative and adaptable solutions but requiring more prompt engineering skill.

Experiment with different prompt strategies in Pi agent to leverage the model's inherent reasoning capabilities.


Pi agent allows the use of any model, unlike Claude Code which prioritizes its own cloud models.

Provides flexibility to choose the best model for a specific task, potentially reducing costs or improving performance.

Evaluate different models with Pi agent to identify the optimal model for various coding tasks.


Pi agent's design philosophy is 'If I don't need it, it won't be built,' resulting in a minimal and unopinionated tool that requires more initial setup but offers greater control.

Requires a higher initial investment of time and effort but allows for a highly tailored and efficient agentic coding workflow.

Assess the team's needs and skills to determine if Pi agent's customization benefits outweigh the initial setup effort.


Pi agent emphasizes observability, surfacing as much information as possible to the user, while Claude Code abstracts away many details.

Provides greater transparency and control over the agent's actions, facilitating debugging and optimization.

Utilize Pi agent's observability features to understand the agent's reasoning process and identify areas for improvement.


Pi agent's open-source nature allows for pinning versions and rolling back changes, providing greater stability and control over the tool's evolution.

Reduces the risk of disruptive updates and allows engineers to maintain a consistent workflow.

Implement a version control strategy for Pi agent to ensure stability and prevent unexpected changes.


The video highlights the importance of programmatic support for agents, enabling out-of-the-loop agent coding and product development.

Allows for the creation of automated workflows and agent-powered applications, moving beyond terminal-based interactions.

Develop programmatic interfaces for Pi agent to integrate it into existing workflows and build agent-powered products.


The video showcases the creation of custom extensions for Pi agent, including a 'till done' extension that enforces a task list workflow and a sub-agent extension for parallel task execution.

Demonstrates the power of Pi agent's extensibility and the ability to create custom agentic workflows tailored to specific needs.

Explore the creation of custom extensions for Pi agent to address specific engineering challenges and improve workflow efficiency.


Claude Code is positioned as the leading out-of-the-box agentic coding tool, while Pi agent is presented as a customizable counterattack for advanced engineers.

Highlights the different target audiences and value propositions of the two tools.

Evaluate both Claude Code and Pi agent to determine which tool best aligns with the team's skills, needs, and goals.


The video emphasizes the need to hedge agentic engineering by using multiple tools and not relying solely on one solution.

Reduces the risk of being locked into a single vendor or tool and allows for the selection of the best tool for each specific task.

Develop a strategy for using both Claude Code and Pi agent to leverage their respective strengths and mitigate their weaknesses.


Pi agent lacks sub-agent support out-of-the-box, but the video demonstrates how to build it using custom extensions.

Highlights the need for custom development to achieve certain functionalities in Pi agent but also showcases its extensibility.

Evaluate the need for sub-agent support and consider developing a custom extension for Pi agent if required.


The 'till done' extension for Pi agent allows for the creation of deterministic agentic loops by enforcing a task list workflow and requiring agent actions to be approved.

Provides greater control and predictability over the agent's behavior, reducing the risk of errors and improving reliability.

Explore the use of the 'till done' extension or similar custom extensions to create deterministic agentic loops for critical tasks.


The video mentions that security in agentic coding is mostly theater and that Pi agent prioritizes functionality over out-of-the-box safety features.

Highlights the importance of understanding the security implications of agentic coding and implementing appropriate safeguards.

Implement security measures and access controls for Pi agent to protect sensitive data and prevent unauthorized actions.


The video mentions Mario as the author of Pi agent and highlights his unique approach to agentic coding.

Provides context about the tool's development and philosophy.

Research Mario's work and contributions to the agentic coding space to gain a deeper understanding of Pi agent's design principles.


Skills are becoming more important and popular because they allow deploying prompts and code against any problem in a consistent, reusable way.

Highlights the value proposition of skills in agentic workflows.

Prioritize the development and use of reusable skills for common tasks.


The core for context model prompt tools (context, model, prompt, tools) is a useful framework for building skills.

Provides a structured approach to skill development.

Adopt the context, model, prompt, tools framework for designing and implementing skills.


The speaker uses a 'cookbook' directory within skills to progressively disclose information to agents on a per-use-case basis.

Allows for more nuanced and context-aware agent behavior.

Implement a 'cookbook' directory structure in skills to provide agents with additional documentation and context-specific instructions.


The speaker emphasizes the importance of planning and defining the desired end state before using agents.

Prevents over-reliance on agents and ensures alignment with goals.

Establish a clear plan and define the desired output before engaging agents for task execution.


The speaker uses in-loop agentic coding, where the human presence and effort are high.

Allows for greater control and oversight during the development process.

Consider using in-loop agentic coding for complex or critical tasks where human oversight is necessary.


The speaker uses prompt code snippets to accelerate skill writing.

Increases efficiency and consistency in prompt engineering.

Create and maintain a library of prompt code snippets for common tasks and skill structures.


The speaker uses OAS script on Mac to open new terminal windows programmatically.

Enables the creation of skills that can automate terminal interactions.

Investigate and implement OAS script or similar tools for automating terminal interactions on different operating systems.


The speaker advocates for agents to use the `-help` flag to understand CLI commands before execution.

Improves agent accuracy and reduces errors when interacting with CLIs.

Implement a mechanism for agents to automatically use the `-help` flag to understand CLI commands before execution.


Cursor IDE is favored for its tab completion model.

Highlights a specific feature that improves developer productivity.

Evaluate Cursor IDE, focusing on its tab completion capabilities, as a potential tool for agentic coding.


Astral UV is considered the best Python tooling.

Suggests a preferred tool for Python-based agent development.

Adopt Astral UV for Python-based agent development projects.


Gemini 3 Flash is a top 3 intelligence model at a top 5 price and high speed (200 tokens/second), supporting text, images, audio, video, and PDF inputs.

Gemini 3 Flash should NOT EXIST. TOP 2% Engineering. /PLAN 2026

Provides engineers with a high-performance, cost-effective model for agentic systems.

Evaluate Gemini 3 Flash for integration into existing or new agentic workflows to leverage its performance and cost benefits.


Gemini 3 Flash usage on Open Router has increased by 385% and is predicted to reach the top 5 most used models by the end of the year.

Indicates strong adoption and potential for Gemini 3 Flash to become a dominant model in the agentic space.

Monitor Gemini 3 Flash usage trends and community feedback to assess its long-term viability and potential for specific use cases.


The speaker believes the primary limitation for engineers in 2026 will be trust in their agents, not the models themselves.

Shifts focus from model selection to building reliable and trustworthy agentic systems.

Prioritize building agentic systems with robust error handling, monitoring, and explainability to increase trust and adoption.


Trust in agents leads to speed, which leads to iteration, which leads to impact.

Highlights the importance of trust as a key driver of productivity and innovation in agentic engineering.

Implement strategies to build trust in agentic systems, such as thorough testing, clear communication of agent behavior, and user feedback mechanisms.


Anthropic (Claude) is positioned as a leader in agentic coding tools, particularly with Claude Code and its SDK.

Suggests focusing on Anthropic's offerings for building robust agentic systems.

Investigate and utilize Claude Code and its SDK for building custom agents and agentic workflows.


Only 15% of output tokens are tool calls, representing a significant opportunity for engineers to increase agent impact.

Highlights the potential for increasing agentic system effectiveness by focusing on tool integration and automation.

Design agentic systems that heavily utilize tool calling to automate tasks and increase overall impact.


Custom agents with custom tools are the best way to maximize tool calls and impact.

Emphasizes the importance of tailoring agents to specific problems for optimal performance.

Develop custom agents with specific tools and prompts to address unique engineering challenges.


Every major AI lab has an agent SDK, and engineers should pick one and learn to use it.

Highlights the importance of mastering agent SDKs for building and deploying custom agents.

Evaluate and select an agent SDK (e.g., Claude Agent SDK) and invest in training and development to build custom agents.


Multi-agent orchestration is the next big trend, where multiple agents work together to solve problems.

Suggests exploring multi-agent systems for complex tasks that require coordination and collaboration.

Research and experiment with multi-agent orchestration patterns, including agent communication, task delegation, and conflict resolution.


Agent sandboxes provide a safe environment for agents to run and experiment without impacting the main system.

Reduces risk and increases trust by isolating agent execution.

Implement agent sandboxes to isolate agent execution and prevent unintended consequences.


Top engineers will progressively offload more tasks into their outloop agentic coding system, maximizing automated tasks and minimizing manual intervention.

Increases efficiency by automating routine tasks and freeing up engineers for more complex work.

Develop outloop agentic coding systems to automate tasks and minimize manual intervention, gradually increasing the scope of automation.


Agentic Coding 2.0 involves agents that conduct agents, where a lead agent spins up the right agent for the job.

Represents a more advanced form of multi-agent orchestration with dynamic agent selection.

Explore Agentic Coding 2.0 patterns, where a lead agent dynamically selects and orchestrates other agents to perform specific tasks.


Opus 4.5 excels at managing teams of sub-agents, enabling the construction of well-coordinated multi-agent systems.

Enables more complex and automated workflows by distributing tasks among multiple agents.

Explore using Opus 4.5 for multi-agent orchestration in engineering workflows.


Anthropic is training Opus 4.5 to be a better prompt engineer, specifically for prompting sub-agents.

Opus 4.5 can generate more effective prompts for sub-agents, leading to better task execution.

Leverage Opus 4.5's prompt engineering capabilities for sub-agent delegation tasks.


Opus 4.5 pricing is significantly reduced compared to Opus 4.1, making it a state-of-the-art model with state-of-the-art pricing.

Increased affordability makes Opus 4.5 a more attractive option for engineering tasks.

Evaluate Opus 4.5 pricing and performance against other models like Gemini 1.5 Pro for cost-effectiveness.


The speaker uses E2B as a sandbox host for agents, highlighting its usefulness for isolated agent environments.

Provides a secure and isolated environment for agents to execute code and interact with external resources.

Evaluate E2B for agent sandboxing and compare it with other similar tools.


The speaker emphasizes the importance of agent sandboxes for building and testing full-stack applications with agents.

Enables agents to create and manage entire application environments, facilitating rapid prototyping and testing.

Implement agent sandboxes in engineering workflows to automate application development and testing.


The speaker uses a consistent prompt format for agent interactions, emphasizing the importance of consistency for effective communication with agents.

Improved agent understanding and task execution through clear and consistent prompts.

Develop and enforce a consistent prompt format for all agent interactions.


The speaker provides a link to a free agent skill codebase, offering tools for operating sandboxes and running prompts inside skills.

Provides a starting point for building and deploying agent-based applications.

Explore the agent skill codebase and integrate it into existing engineering workflows.


The speaker uses a multi-step agentic workflow: Plan, Build, Host, Test, Respond, with a feedback loop to improve application development.

Automates the entire application development lifecycle, from planning to testing.

Implement the Plan, Build, Host, Test, Respond workflow in engineering projects.


Opus 4.5 is particularly well-suited for engineering tasks due to its ability to delegate work and handle long-running tasks.

Increased efficiency and automation in engineering workflows.

Prioritize Opus 4.5 for engineering tasks that require delegation and long-running processes.


The speaker uses a 'generic browser test' prompt to automate UI testing with sub-agents, showcasing the ability to test full-stack applications dynamically.

Enables comprehensive and automated UI testing, improving application quality.

Implement automated UI testing workflows using the 'generic browser test' prompt or similar approaches.


The speaker emphasizes the importance of mastering the agent, not just the prompt, for effective knowledge work and engineering.

Shifts focus from individual prompts to agent architectures and agentic systems.

Focus on developing agent architectures and agentic systems, rather than solely optimizing prompts.


The speaker uses forking to spin off agent work on multiple problems.

Enables parallel processing of multiple engineering tasks.

Explore agent forking to improve engineering workflow efficiency.


Thread-based engineering is a framework for operationalizing agents to continuously improve by measuring the value agents create in tool calls.

AGENT THREADS. How to SHIP like Boris Cherny. Ralph Wiggum in Claude Code.

Provides a structured approach to agentic engineering and measuring progress.

Adopt thread-based engineering framework to track and improve agent performance.


The base thread consists of a prompt/plan, agent work (tool calls), and a review/validation step.

Defines the fundamental unit of work in agentic engineering.

Structure agent interactions around the base thread model.


Pthreads (parallel threads) involve running multiple agents simultaneously to increase output and tap into more compute.

Increases throughput and allows for faster experimentation.

Implement Pthreads to parallelize agent tasks and accelerate development.


Boris Cherny runs 5 Claude instances in parallel in his terminal and 5-10 in the Cloud Code web interface.

Demonstrates a real-world example of Pthreads in action.

Experiment with running multiple agent instances in parallel to improve efficiency.


Cthreads (chained threads) are used for large, multi-phase plans where work is intentionally chunked due to context window limitations or high-pressure production work.

Enables handling of complex tasks that exceed context limits or require careful monitoring.

Utilize Cthreads for tasks that require breaking down into smaller, manageable phases.


Fthreads (fusion threads) involve sending the same or similar prompts to multiple agents, reviewing the results, and combining them for a superior outcome.

Increases confidence in results and facilitates rapid prototyping.

Implement Fthreads for tasks where multiple perspectives or solutions are desired.


Bthreads (big threads) are meta-structures where prompts fire off other prompts, such as using sub-agents or orchestrator agents.

Enables complex workflows and team-based agent interactions.

Explore Bthreads for orchestrating complex agent workflows and team-based agent interactions.


Lthreads are long-duration, high-autonomy workflows with minimal human intervention.

Allows agents to run for extended periods, accomplishing significant tasks with minimal oversight.

Design Lthreads for tasks that can be automated and run for extended periods.


The Ralph Wiggum pattern (looping over an agent) is gaining traction as a way to achieve longer chains of work with more autonomy.

Enables agents to continuously iterate and improve their work.

Implement the Ralph Wiggum pattern to enable agents to continuously improve their work.


The agent stop hook allows for deterministic code to intercept and validate agent work before continuing or completing the workflow.

Provides a mechanism for integrating traditional code with agentic workflows.

Utilize the agent stop hook to integrate deterministic code for validation and control.


Four ways to improve agentic engineering: run more threads, run longer threads, run thicker threads, and run fewer human-in-the-loop checkpoints.

Provides a concrete framework for improving agent performance.

Focus on increasing the number, length, and thickness of threads while reducing human intervention.


Boris Cherny uses Opus 4.5 and keeps Claude's context in the repo but not too large.

Provides insights into practical context management strategies.

Experiment with Opus 4.5 and optimize context management for Claude.


Boris Cherny emphasizes the importance of giving agents a way to verify their work, creating a validation loop.

Highlights the importance of feedback loops for agent self-improvement.

Implement validation loops to enable agents to verify and improve their own work.


The speaker recommends building a specialized agentic layer around your codebase for production assets.

Suggests a strategy for creating custom agents tailored to specific problems.

Develop a specialized agentic layer around your codebase for production assets.


Claude Code Task System allows for reliable and consistent creation of teams of agents.

Claude Code Task System: ANTI-HYPE Agentic Coding (Advanced)

Enables more organized agents that can communicate together to work toward a common goal.

Explore and implement the Claude Code Task System for creating agent teams.


The 'plan with team' prompt utilizes self-validation, agent orchestration, and templating.

Ensures plan creation, guides team composition, and promotes consistent prompt generation.

Adopt the 'plan with team' prompt structure for agentic workflows.


Agents can be self-validating using specialized scripts to check their own work.

Increases reliability and reduces errors in agent outputs.

Implement self-validation scripts in agents using 'validate new file' and 'validate file contains' hooks.


The Claude Code Task System includes task management tools like task create, update, list, and get.

Facilitates communication and coordination between primary and sub-agents.

Utilize task management tools for agent communication and task dependency management.


The task update function is crucial for sub-agents and the primary agent to communicate progress and status updates.

Enables real-time feedback and dynamic task adjustments.

Prioritize the use of 'task update' for agent communication in task-based workflows.


The system supports multi-agent teams with more than one primary agent.

Enables complex workflows with distributed responsibilities.

Explore multi-agent team configurations for complex tasks.


Templating allows teaching agents to build in a specific, vetted, and consistent format.

Ensures predictable and reliable agent outputs.

Use template metaprompts to generate prompts in a specific format.


Builder and validator agent pairing increases compute and trust in work delivered.

Improves the quality and reliability of agent-generated code.

Implement builder/validator agent pairs for code generation and review tasks.


The speaker advocates for building an 'agentic layer' of the codebase instead of working directly on the application.

Shifts focus to automating development processes.

Prioritize building and maintaining agents that automate development tasks.


The Claude Code Task System enables longer running threads of work because the primary agent can orchestrate a massive task list, kick it off, and then as agents complete it will receive specific events.

Allows for more complex and sustained agentic workflows.

Design workflows that leverage the task system for long-running, multi-stage processes.


The speaker mentions the importance of focused context windows for agents.

Improves agent performance by limiting the scope of each task.

Design agents with narrow, well-defined tasks to maximize performance.


The speaker contrasts the Claude Code Task System with 'vibe coding' and 'slop engineering' where the agent's actions are unpredictable.

Highlights the importance of understanding and controlling agent behavior.

Prioritize structured and predictable agent workflows over ad-hoc prompting.


The speaker mentions Ralph Wickham's techniques and multi-agent orchestration as emerging trends.

Indicates areas for further research and development.

Research and experiment with Ralph Wickham's techniques and advanced multi-agent orchestration strategies.


The speaker expresses a desire for better documentation of the Claude Code Task System.

Highlights a potential barrier to adoption and effective use.

Monitor Anthropic's documentation updates for the Claude Code Task System and contribute to community resources.


The speaker uses a metaprompt that takes an orchestration prompt as input to guide team composition.

Allows for flexible and reusable team orchestration strategies.

Develop and maintain a library of orchestration prompts for different team configurations.


The speaker mentions using hooks for self-validation and error handling.

Enables robust and reliable agentic workflows.

Implement hooks for self-validation, error handling, and logging in agents.


The speaker mentions the ability to build specialized agents that do one thing extraordinarily well.

Improves agent performance and reduces errors.


The speaker mentions the ability to build in micro steps of validation inside the builder agent.

Implement micro steps of validation inside the builder agent.


Prioritize CLIs over MCP servers for agentic workflows due to token efficiency and customization capabilities.

My 4-Layer Claude Code Playwright CLI Skill  (Agentic Browser Automation)

Reduced token consumption and increased flexibility in agent design.

Evaluate existing MCP-based workflows and migrate to CLI-based solutions where feasible.


Leverage Playwright CLI for headless browser automation and UI testing with parallel sessions and persistent profiles.

Improved efficiency and scalability of browser automation tasks.

Implement Playwright CLI for UI testing and browser automation, focusing on headless execution, parallel sessions, and persistent profiles.


Implement a four-layer agentic architecture: Skills (capabilities), Agents (scaling), Commands (orchestration), and Justfiles (reusability).

Structured and scalable agentic workflows.

Refactor existing agentic systems to align with the four-layer architecture for improved organization and reusability.


Use sub-agents to scale specific tasks and workflows, especially with new agent orchestration features.

Increased efficiency and parallelization of complex tasks.

Identify tasks suitable for sub-agent delegation and implement sub-agent workflows, leveraging agent orchestration features.


Employ custom commands (reusable prompts) for orchestrating agent workflows and creating specialized solutions.

Simplified and repeatable execution of complex agent tasks.

Develop custom commands for common agent workflows, focusing on reusability and specialization.


Utilize a task runner like 'just' for reusability and quick access to agentic commands and workflows.

Streamlined execution and management of agentic tasks.

Integrate a task runner like 'just' into the agentic workflow for easy access and execution of commands.


Implement a higher-order prompt (HOP) pattern for browser automation to wrap prompts in consistent workflows.

Standardized and repeatable browser automation tasks.

Develop HOPs for common browser automation tasks to ensure consistent execution and error handling.


Capture screenshots at each step of agent workflows for debugging and validation.

Improved debugging and traceability of agent actions.

Integrate screenshot capture into agent workflows to provide visual records of agent actions.


Use agents for UI testing by having them operate like users, validating workflows against URLs.

Simplified UI testing with flexible workflow creation.

Implement agent-based UI testing by creating user stories with URLs and workflows for agents to validate.


Explore agent orchestration features for creating teams of agents working towards a common goal.

Enhanced collaboration and efficiency in complex tasks.

Investigate and implement agent orchestration features to create agent teams for complex tasks like UI review.


Gemini 3 Pro is the new top model, surpassing Claude Code (Sonnet 4.5) in benchmarks.

I gave Gemini 3 Pro its own computer... it's official, Claude Code has COMPETITION

Indicates a shift in the competitive landscape of LLMs, requiring re-evaluation of model choices for agentic workflows.

Prioritize Gemini 3 Pro for new agent deployments and benchmark against existing Claude Code deployments to assess performance gains.


The presenter is using E2B to host and run agent sandboxes, providing dedicated computers for agents.

Highlights a specific tool (E2B) for managing agent environments, enabling autonomy and scalability.

Evaluate E2B for agent environment management, focusing on cost, integration with existing infrastructure, and security features.


The presenter reprograms agents using memory files and a custom backslash command to execute reusable prompts and skills.

Demonstrates a method for extending agent functionality and creating custom workflows through dynamic prompt injection and skill execution.

Investigate the use of memory files and custom commands for agent reprogramming, focusing on security implications and potential for prompt injection vulnerabilities.


The presenter emphasizes the importance of agentic experience and building agent ecosystems over raw model intelligence.

Shifts focus from model performance to the overall agentic system, including tooling, workflows, and environment.

Prioritize the development of robust agentic systems and workflows, focusing on usability, scalability, and integration with existing tools and data sources.


The presenter uses agent sandboxes to deploy multiple agents against the same problem and choose the best result (best-of-end approach).

Illustrates a strategy for improving agent reliability and performance by leveraging redundancy and competition.

Implement a best-of-end strategy for critical agent tasks, deploying multiple agents in parallel and selecting the optimal output based on predefined criteria.


The presenter is building full-stack applications (front-end, back-end, database) using agentic workflows.

Demonstrates the capability of agents to perform complex engineering tasks, including application development.

Explore the use of agentic workflows for full-stack application development, focusing on automating repetitive tasks and accelerating development cycles.


The presenter mentions using a 170-line prompt for agentic workflows, showcasing complex prompt engineering.

Highlights the importance of detailed and well-structured prompts for achieving desired agent behavior.

Develop a library of reusable agentic prompts for common engineering tasks, focusing on clarity, completeness, and adaptability.


The presenter highlights the importance of terminal benchmarks and long durations of agentic work as key performance indicators.

Suggests specific metrics for evaluating the effectiveness of agentic systems in real-world engineering scenarios.

Implement terminal benchmarks and track agentic work durations to monitor performance improvements and identify areas for optimization.


The presenter uses agent sandboxes to provide isolation, security, and scale for agent deployments.

Emphasizes the benefits of containerization and virtualization for managing agent environments.

Adopt containerization or virtualization technologies to isolate agent environments, improve security, and enable scalable deployments.


The presenter observed a 20% context window increase in Codeex, potentially due to context compression and tool calling deletion.

Indicates potential advancements in context management within Codeex, which could improve agent performance and efficiency.

Investigate context compression and tool calling deletion techniques in Codeex to understand their impact on agent performance and explore similar techniques for other LLMs.


The presenter uses backslash commands to trigger agent skills, effectively creating a custom command-line interface for the agents.

Demonstrates a method for creating a more intuitive and user-friendly interface for interacting with agents.

Design and implement custom command-line interfaces for agents using backslash commands or similar mechanisms to simplify interaction and improve usability.


The presenter is using a chained agentic workflow with steps like plan, build, host, and test.

Illustrates a structured approach to agentic task execution, breaking down complex tasks into smaller, manageable steps.

Adopt a chained agentic workflow approach for complex tasks, defining clear steps and dependencies to ensure efficient and reliable execution.


Cloud Code now supports pre-tool use, post-tool use, and stop hooks in prompts, sub-agents, and skills, enabling specialized self-validation.

The Claude Code Feature Senior Engineers KEEP MISSING

Allows for deterministic validation of agent actions, increasing trust and reducing engineering time spent on validation.

Explore and implement pre/post-tool use and stop hooks in existing and new agent workflows to ensure data integrity and improve agent reliability.


The speaker emphasizes the importance of building focused agents that do one thing extraordinarily well, as they outperform unfocused agents with many tasks.

Improved agent performance and reliability.

Refactor existing general-purpose agents into smaller, specialized agents with clearly defined responsibilities.


The speaker uses a pattern called 'agentic prompt template' which includes front matter for hooks, allowing for reusable prompt formats.

Streamlines prompt creation and ensures consistency across agents.

Develop and implement a standardized 'agentic prompt template' with front matter for hooks to facilitate prompt creation and maintain consistency.


The speaker organizes codebases with a 'hooks' directory containing 'validators' for self-validation.

Improved code organization and maintainability.

Adopt a similar directory structure for agent projects, including a 'hooks' directory with validators for self-validation.


The speaker highlights the importance of observability and logging everything, especially validator outputs.

Facilitates debugging and monitoring of agent performance.

Implement comprehensive logging for agent actions and validator outputs to enable effective debugging and performance monitoring.


The speaker uses UV run to execute validation scripts within the agent workflow.

Enables seamless integration of validation logic into agent execution.

Investigate and integrate UV run or similar tools into agent workflows to execute validation scripts.


The speaker advocates for 'agents plus code beats agents,' emphasizing the importance of incorporating code-based validation into agent workflows.

Increased trust and reliability in agent outputs.

Prioritize the integration of code-based validation mechanisms into agent workflows to enhance trust and reliability.


The speaker uses sub-agents to parallelize tasks and isolate context, deploying one agent per file.

Improved scalability and efficiency of agent workflows.

Leverage sub-agents to parallelize tasks and isolate context, especially when processing multiple files or data sources.


The speaker uses a 'damage control skill' with hooks to protect the codebase and block commands.

Enhanced security and stability of the agent system.

Develop and implement similar 'damage control' mechanisms to protect the codebase and prevent unintended actions by agents.


Cloud Code is merging skills and custom slash commands, effectively making everything a prompt.

Simplifies the agent development process by unifying different agent components.

Adapt agent development strategies to the unified prompt-based approach in Cloud Code, focusing on the core four (context, model, prompt, tools).


The speaker uses HTML validators to validate the output of generative UI agents.

Ensures the quality and correctness of generated UI elements.

Incorporate HTML validators into generative UI agent workflows to ensure the quality and correctness of generated UI elements.


The speaker uses both post-tool use hooks for single-file validation and stop hooks for global validation across multiple files.

Provides flexibility in implementing validation strategies based on the scope of the task.

Utilize post-tool use hooks for targeted validation of individual file operations and stop hooks for comprehensive validation across multiple files.


The speaker mentions a 'review finances' agent pipeline that chains together multiple specialized agents, each validating their work.

Demonstrates a complex multi-agent system with built-in validation at each step.

Design and implement multi-agent pipelines with specialized agents, incorporating validation at each stage to ensure end-to-end reliability.


The speaker is against generalist 'do it all' agents and advocates for specialized agents that excel at one task.

Improved agent performance, scalability, and maintainability.

Prioritize the development of specialized agents over generalist agents to optimize performance, scalability, and maintainability.


The speaker uses a CSV validator that identifies and automatically fixes errors in CSV files.

Demonstrates self-healing capabilities in agents.

Develop agents with self-healing capabilities by incorporating validation and error correction mechanisms.


The speaker uses a normalized CSV agent that runs two validators on the stop command to test all files in the codebase.

Ensures data integrity and consistency across the entire codebase.

Implement global validators that run on the stop command to ensure data integrity and consistency across the entire codebase.


E2B Agent Sandboxes provide isolated environments for agents, allowing for greater autonomy and control.

E2B Agent Sandboxes: The Space to Place your Claude Agents

Enables agents to perform tasks without interfering with other processes or the host system.

Evaluate E2B Agent Sandboxes for agent-based workflows.


Agent sandboxes enable scaling agentic workflows by running multiple agents in parallel.

Accelerates task completion and allows for exploring multiple solutions simultaneously.

Design agentic workflows that can leverage parallel execution in sandboxes.


The 'best of n' pattern can be implemented using agent sandboxes to generate multiple solutions and select the best one.

Improves the quality of solutions by exploring a wider range of possibilities.

Incorporate the 'best of n' pattern into agentic workflows using sandboxes.


Agent sandboxes are ephemeral and have a limited lifetime, requiring careful planning and execution.

Requires efficient resource management and workflow design to maximize the use of sandbox time.

Implement monitoring and logging to track agent progress and ensure timely completion of tasks within the sandbox lifetime.


Orchestrator agents can be used to manage and coordinate multiple agents running in sandboxes.

Simplifies complex workflows and allows for centralized control and monitoring of agent activities.

Develop orchestrator agents to manage and coordinate agent sandboxes.


E2B provides templates for sandboxes, allowing for pre-configured environments with specific packages and dependencies.

Reduces setup time and ensures consistency across different agent environments.

Create and utilize E2B templates for common agent workflows.


The speaker uses a custom agent built with Cloud Code Agent SDK, with allowed and disallowed tools defined in the config.

Demonstrates the ability to create specialized agents with controlled access to specific tools.

Explore the Cloud Code Agent SDK for building custom agents with tailored toolsets.


The speaker uses an MCP (Management Control Plane) server to wrap the E2B CLI for easier agent interaction with the sandboxes.

Provides a higher-level interface for managing and controlling agent sandboxes.

Investigate MCP patterns for managing agent infrastructure.


Engineering with agents requires a focus on planning and reviewing, especially when scaling up agent deployments.

Highlights the importance of effective review processes to manage the output of multiple agents.

Develop robust review workflows for agent-generated outputs, including automated filtering and prioritization.


Agent sandboxes enable scaling compute to scale impact, allowing for solving problems multiple times with different approaches.

Increases the likelihood of finding optimal solutions by exploring a wider range of possibilities.

Design agentic workflows that leverage the ability to scale compute and explore multiple solutions in parallel.


E2B and U Modal are mentioned as agent sandbox tools.

Provides options for selecting an agent sandbox platform.

Evaluate U Modal alongside E2B for agent sandbox capabilities.


Agent sandboxes are currently used by Fortune 100 companies and are an emerging trend.

Indicates the growing importance of agent sandboxes in enterprise AI development.

Monitor the adoption of agent sandboxes in the industry.


The speaker emphasizes the importance of prompt engineering and context engineering for effective agent performance.

Highlights the need for well-designed prompts and context to guide agent behavior.

Invest in prompt engineering training and best practices.


Agent sandboxes can be used for reinforcement learning, data analytics, and isolated fast one-off environments.

Demonstrates the versatility of agent sandboxes for various AI applications.

Explore the use of agent sandboxes for reinforcement learning and data analytics projects.


Agent sandboxes provide isolation, scale, and agency to agents.

These features are crucial for building robust and scalable agentic systems.

Prioritize isolation, scale, and agency when designing agentic workflows.


The speaker mentions the cost associated with running multiple agents in sandboxes using API keys.

Highlights the need for cost optimization when scaling agent deployments.

Implement cost tracking and optimization strategies for agent sandbox usage.


The speaker uses GitHub PRs to review the code changes made by the agents in the sandboxes.

Demonstrates a practical workflow for integrating agent-generated code into existing codebases.

Integrate agent sandbox workflows with existing code review processes using GitHub PRs or similar tools.


The speaker highlights the importance of treating agents as deletable resources with a single purpose.

Promotes efficient resource utilization and reduces the risk of context contamination.

Design agents with a clear purpose and ensure they are properly terminated after completing their tasks.


The speaker mentions that the system prompt completely overrides the Claude Code system prompt, making it a true custom agent.

Allows for complete control over agent behavior and customization.

Leverage the ability to override system prompts for creating highly specialized agents.


The speaker showcases how agents can be used to improve landing pages based on Reddit feedback.

Demonstrates a practical application of agent sandboxes for iterative design and development.

Explore the use of agent sandboxes for A/B testing and user interface optimization.


Claude Opus 4.6 is beating all benchmarks but the focus is on multi-agent orchestration.

Claude Code Multi-Agent Orchestration with Opus 4.6, Tmux and Agent Sandboxes

Highlights the importance of tooling and prompt engineering over raw model performance.

Prioritize development of robust tooling and prompt engineering skills for leveraging powerful models.


The true constraint of agentic engineering is the available tools and the user's ability to prompt engineer and context engineer.

Focus shifts from model capabilities to user skills and tooling.

Invest in training and development of prompt engineering and context engineering skills within the team.


Multi-agent orchestration and multi-agent observability are key to unlocking the full potential of powerful models.

Highlights the need for systems that allow for coordinated agent actions and monitoring.

Implement multi-agent orchestration and observability frameworks to improve agentic workflows.


T-Mox is used to create multiple panes for visualizing and interacting with different agents simultaneously.

Provides a method for managing and observing multiple agents in parallel.

Explore and implement T-Mox or similar terminal multiplexers for improved multi-agent management.


Cloud Code has an experimental agent teams feature that can be enabled.

Unlocks new multi-agent orchestration capabilities within Cloud Code.

Investigate and enable the Cloud Code experimental agent teams feature.


Agents create task lists to manage their work and assign tasks to sub-agents.

Provides a structured approach to multi-agent task management.

Implement task list management systems for multi-agent workflows.


Agents can open up new panes in T-Mox for each sub-agent they want to run.

Enables visual separation and management of sub-agent processes.

Integrate pane management into multi-agent orchestration frameworks.


The speaker uses E2B as an agent sandbox environment.

Provides a secure and isolated environment for agent execution.

Evaluate and implement agent sandbox environments like E2B.


The speaker has a skill to list all running sandboxes and manage them at scale.

Enables efficient management of multiple agent sandbox environments.

Develop or adopt skills for managing agent sandboxes at scale.


The core four concepts are context, model, prompt, and tools.

Highlights the fundamental components of agentic coding.

Ensure that all agentic development efforts are aligned with the core four principles.


New tools for multi-agent orchestration include team management (team create, team delete), task management (task create, task list, task get, task update), and communications (send message).

Provides specific tools for building and managing multi-agent systems.

Integrate these new tools into existing agentic workflows.


The multi-agent orchestration workflow involves creating a team, creating tasks, spawning agents, working in parallel, shutting them all down, and deleting the team.

Defines a clear process for multi-agent orchestration.

Adopt this workflow for multi-agent projects.


Deleting agents after work is done forces a good pattern of context engineering where you reset the context and start over.

Improves agent performance and reduces context contamination.

Implement a policy of deleting agents after their tasks are completed.


Tactical Agentic Coding course covers multi-agent orchestration and advanced agentic engineering.

Provides a resource for learning advanced agentic coding techniques.

Evaluate the Tactical Agentic Coding course for potential training opportunities.


The speaker is burning through API credits, suggesting a cost associated with running multiple agents and sandboxes.

Highlights the potential cost implications of scaling agentic workflows.

Monitor API usage and optimize agent workflows to reduce costs.


Cloud Code released a setup hook that runs before sessions start, allowing for actions like installing dependencies, running migrations, or periodic maintenance tasks.

One Prompt Every AGENTIC Codebase Should Have (For Engineering Teams)

Provides a deterministic entry point for setup and maintenance tasks.

Investigate Cloud Code's setup hook and integrate it into existing codebases.


Combining deterministic hooks (like Cloud Code's setup hook) with standardized agentic prompts yields predictable execution, intelligent oversight, and interactivity.

Improves codebase maintainability and onboarding efficiency.

Develop standardized agentic prompts for common setup and maintenance tasks, leveraging deterministic hooks.


Justfile is a simple command runner that serves as a launchpad for engineering work, allowing teams and agents to easily execute commands with pre-defined flags.

Simplifies command execution and promotes code reuse.

Evaluate and adopt Justfile for managing commands and agent workflows within codebases.


The speaker uses a /prime command (similar to a claw.md file) to provide context to the agent about the codebase before running installation or maintenance tasks.

Enables agents to understand the codebase and perform tasks more effectively.

Implement a similar priming mechanism to provide context to agents before executing tasks.


The speaker demonstrates an interactive installation process where the agent asks questions and the user provides input, allowing for customized setup.

Improves onboarding experience and allows for flexible configuration.

Develop interactive prompts for common setup and maintenance tasks to guide users through the process.


The speaker highlights the importance of logging and documentation in conjunction with agents, allowing agents to read logs and report on the results of deterministic scripts.

Enhances agent observability and debugging capabilities.

Implement robust logging and documentation practices to support agent-driven workflows.


The speaker suggests encoding common workflow resolution steps into prompts to handle potential issues during installation or maintenance.

Improves agent robustness and reduces the need for human intervention.

Identify common issues during setup and maintenance and encode solutions into prompts.


The speaker emphasizes the importance of standardizing installation and maintenance processes using agents, prompts, and deterministic hooks.

Improves consistency, reduces errors, and streamlines onboarding.

Develop and enforce standardized workflows for setup and maintenance using agents and deterministic code.


The speaker mentions Mintfi's blog post about building a standard for LLM executables, indicating a growing trend towards agentic codebases.

Validates the speaker's approach and suggests a potential market for agentic tooling.

Monitor the development of standards for LLM executables and contribute to the discussion.


The speaker suggests using agents for scheduled health checks and updating vulnerable packages, indicating a potential for proactive maintenance.

Improves codebase security and reduces the risk of vulnerabilities.

Develop agents for performing scheduled health checks and updating vulnerable packages.


The speaker describes the install and maintenance prompts as a 'living document that executes', highlighting the potential for natural language communication of action.

Improves collaboration and reduces the need for technical documentation.

Focus on creating prompts that are easy to understand and modify, allowing for natural language communication of action.


Clawed Code Damage Control skill uses local, global, and prompt hooks to prevent agents from running destructive commands.

Claude Code is Amazing... Until It DELETES Production

Prevents accidental or malicious deletion of critical code and data by AI agents.

Implement Clawed Code Damage Control or similar hook-based system in production environments using AI agents.


The system uses a 'prompt hook' as a last-ditch effort to catch dangerous commands that haven't been explicitly caught by deterministic hooks.

Provides an additional layer of security against unforeseen destructive commands.

Implement a prompt-based pre-tool use hook that uses a LLM to evaluate the safety of commands before execution.


Deterministic hooks should be prioritized for known dangerous commands, while prompt hooks serve as a safety net for unknown commands.

Optimizes performance and security by using deterministic hooks for known threats and prompt hooks for novel threats.

Create a prioritized list of dangerous commands and implement deterministic hooks for them. Supplement with a prompt hook for unknown commands.


The system uses a patterns.yaml file to define disallowed commands and paths, allowing for easy configuration and modification of security rules.

Simplifies the management of security policies and enables agentic modification of these policies.

Implement a configuration file (e.g., YAML) to define disallowed commands, paths, and other security rules.


The system includes 'ask' patterns, where the agent asks for confirmation before running potentially destructive commands.

Provides a human-in-the-loop safety mechanism for critical operations.

Implement a mechanism for agents to request human confirmation before executing commands matching specific patterns.


The system implements zero access paths, read-only paths, and no-delete paths to restrict agent access to sensitive files and directories.

Provides granular control over agent access to critical resources.

Implement access control mechanisms that allow defining zero access, read-only, and no-delete paths for AI agents.


The Clawed Code Damage Control skill is installed using an interactive '/install' command that guides the user through the setup process.

Simplifies the installation and configuration of the security system.

Develop interactive installation scripts for complex tools and frameworks, using the 'ask user question' tool to guide users through the process.


The system uses a cookbook prompt to define the agentic workflow for installation and configuration.

Provides a structured and repeatable process for setting up the security system.

Use cookbook prompts to define agentic workflows for complex tasks, such as installation, configuration, and deployment.


The system supports global hooks, which apply to all codebases on the user's device.

Provides a baseline level of security across all projects.

Implement global hooks or similar mechanisms to enforce security policies across all projects and environments.


Sandboxing is presented as an alternative to damage control, allowing agents to run in isolated environments to prevent damage to production systems.

Reduces the risk of damage by isolating agent execution.

Evaluate and implement sandboxing solutions for AI agents to isolate their execution environment and prevent damage to production systems.


The speaker mentions almost running a catastrophic command in a production application, highlighting the real-world risk of agent errors.

Emphasizes the importance of implementing security measures to prevent accidental damage.

Conduct regular security audits and risk assessments to identify potential vulnerabilities in AI agent workflows.


Agents forget, hindering learning and improvement, unlike traditional software that leverages usage data.

Agent Experts: Finally, Agents That ACTUALLY Learn

Limits agent effectiveness and requires constant manual intervention.

Implement mechanisms for agents to retain and reuse information from past executions.


Memory files, prime prompts, sub-agents, and skills are current solutions, but require manual updates.

Increases maintenance overhead and limits scalability.

Explore automated methods for updating and managing these components.


The core concept is to build agents that automatically learn and reuse expertise at runtime, creating 'agent experts'.

Enables autonomous improvement and reduces reliance on manual intervention.

Prioritize development of self-learning capabilities in agents.


Agent experts maintain a 'mental model' - a data structure that evolves over time with each useful action.

Provides a persistent context for agents to leverage past experiences.

Design and implement robust data structures for representing and updating agent mental models.


The mental model is not a source of truth, but a working memory file that is validated against the code.

Ensures the agent's understanding aligns with the actual system state.

Implement validation mechanisms to ensure the agent's mental model remains consistent with the codebase.


Meta-agentics (meta prompts, meta agents, meta skills) help build elements of the system that build the system.

Increases output as an agentic engineer.

Incorporate meta-agentics into agent development workflows.


Meta-agentics are not agent experts because they don't learn automatically.

Highlights the importance of self-learning in agent expertise.

Focus on adding self-learning capabilities to meta-agentics.


The 'expertise file' (YAML) stores the agent's mental model of the problem space.

Provides a structured way to represent and manage agent knowledge.

Develop and refine the structure and content of expertise files.


The agent expert workflow involves reading the expertise file, validating assumptions against the codebase, and then reporting.

Ensures accuracy and relevance of agent actions.

Implement this workflow in agent designs.


A 'self-improve' prompt allows the agent to sync its mental model with the working codebase.

Enables continuous learning and adaptation.

Develop and integrate self-improvement prompts into agent workflows.


Agent orchestration can be used to scale up agents against a specific problem, improving accuracy and confidence in results.

Enhances the reliability and quality of agent outputs.

Explore and implement agent orchestration strategies for complex tasks.


The speaker uses a 3-step agentic workflow: plan, build, and self-improve.

Provides a structured approach to agent development.

Adopt and adapt this workflow for agent design and implementation.


The speaker uses a 'meta expert' to generate self-improve prompts.

Automates the creation of self-improvement mechanisms.

Investigate and develop meta-experts for generating prompts and other agent components.


Focus on the core four: context, model, prompt, tools.

Provides a foundational framework for agent development.

Prioritize these elements in agent design and implementation.


The agentic layer is a new ring around the codebase where agents operate the application, potentially better than the engineering team.

The Codebase Singularity: “My agents run my codebase better than I can”

Highlights a shift in software engineering where AI agents become central to application operation and development.

Explore and experiment with building an agentic layer around existing codebases to automate tasks and improve efficiency.


The goal is to build an agentic layer so powerful that the codebase runs itself.

Sets a high-level objective for agentic layer development, aiming for complete automation.

Define specific, measurable, achievable, relevant, and time-bound (SMART) goals for automating codebase operations with agents.


The agentic layer is divided into three classes, each with multiple grades, representing increasing levels of agentic capability.

Provides a structured framework for understanding and progressing the development of the agentic layer.

Map current agentic layer capabilities to the class and grade framework to identify areas for improvement.


Class 1 Grade 1 agentic layer consists of a small amount of code and a prime prompt/memory file.

Defines the simplest possible agentic layer, providing a starting point for implementation.

Implement a basic agentic layer with a prime prompt and memory file for a small, well-defined task.


Prime command represents a memory file that can be activated and fine-tuned to run specific workflows.

Provides a mechanism for activating and controlling agent behavior through memory files.

Develop a system for managing and activating prime commands to control agent workflows.


Class 1 Grade 2 incorporates specialized prompts and sub-agents to incrementally improve codebase capabilities.

Introduces the concept of specialized agents for specific tasks, enhancing agentic capabilities.

Identify opportunities to create specialized sub-agents for common tasks within the codebase.


Class 1 Grade 3 introduces skills, MCP servers, and prime commands with tool access to enhance agent capabilities.

Enables agents to interact with external tools and services, significantly expanding their capabilities.

Identify and integrate relevant tools (databases, APIs, etc.) into the agentic layer through skills, MCP servers, or direct prompting.


Skills and MCP servers can be replaced with simple prompts, highlighting the importance of prompt engineering.

Emphasizes the importance of effective prompt engineering as an alternative to complex tool integrations.

Prioritize prompt engineering skills development to optimize agent performance and reduce reliance on external tools.


Class 1 Grade 4 focuses on building feedback loops into the codebase by asking agents to review their work.

Introduces self-correction and continuous improvement through agent-driven code review.

Implement prompts that instruct agents to review their own code and identify potential issues.


Closed-loop prompts (request, validate, resolve) enable agents to spin and spin until the job is done.

Provides a framework for creating self-correcting and iterative agent workflows.

Design and implement closed-loop prompts for critical tasks to ensure thoroughness and accuracy.


Claude Opus 4.6 introduces agent teams, allowing multiple AI agents to work on different parts of a project simultaneously, such as market research, landing page building, and email sequence writing.

Significant increase in project turnaround time and efficiency.

Experiment with agent teams in Claude Opus 4.6 to automate various business processes.


Claude Opus 4.6 has a 1 million token context window, enabling it to hold and remember significantly more information, such as entire business strategies, product docs, and content libraries.

Allows for more comprehensive and context-aware AI assistance, reducing the need for constant context re-introduction.

Leverage the large context window to feed Opus 4.6 with extensive business data for more effective system-level automation.


Claude Opus 4.6 outputs up to 128,000 tokens, double the previous version, allowing for complete finished projects in one shot.

Reduces the need for piecing together outputs from multiple AI interactions.

Utilize the increased output token limit to generate complete deliverables like marketing plans or software code in a single interaction.


Claude Opus 4.6 features adaptive thinking, allocating more processing power to complex tasks and less to simple ones.

Optimizes resource utilization and reduces costs for simple tasks.

Design workflows that leverage adaptive thinking to handle both simple and complex tasks efficiently.


The speaker suggests offering automation services to local businesses, analyzing their workflows, identifying bottlenecks, designing solutions, and implementing them using AI, charging $2,000 to $5,000 per project.

Potential revenue stream by providing AI-powered automation solutions to businesses.

Develop a service offering focused on automating business processes for local businesses using Claude Opus 4.6 and agent teams.


The speaker uses a platform that combines CRM, email marketing, calendars, and payment processing for automated business operations.

Streamlines business operations and reduces the need for manual intervention.

Research and identify platforms that integrate various business functions for automation, potentially including the one mentioned by the speaker.


Claude Opus 4.6 scored 65.4% on Terminal Bench 2.0, indicating strong coding capabilities.

Enables AI-assisted software development and automation of coding tasks.

Evaluate Claude Opus 4.6 for coding tasks and explore its potential for automating software development workflows.


Claude Opus 4.6 scored 76% on long context tests, a significant improvement over the previous version's 18.5%.

Allows for sustained focus and coherence in long-running projects without losing context.

Utilize Claude Opus 4.6 for projects requiring extensive context and long-term memory, such as building marketing funnels or developing software applications.


Claude Opus 4.6 has context compaction, automatically summarizing old information to make room for new data without losing the thread.

Enables continuous operation on long projects without the AI forgetting previous context.

Design long-running AI workflows that leverage context compaction to maintain coherence and avoid the need for constant context re-introduction.


Microsoft integrated Claude Opus 4.6 into their Foundry platform, their enterprise AI infrastructure.

Validates the model's capabilities and provides credibility when pitching services to larger clients.

Mention Microsoft's integration of Claude Opus 4.6 into Foundry when pitching AI-powered services to enterprise clients to enhance credibility.


The speaker offers a free four-part AI FastTrack training and access to a community of agency owners.

Opportunity to learn more about AI tools and connect with other professionals in the field.

Sign up for the free AI FastTrack training and join the community to learn from the speaker and other agency owners.


Kali Linux is a DRO optimized for ethical hacking and includes tools like Nmap, Wireshark, Metasploit, Aircrack, Hashcat, Skipfish, Foremost, SQLmap, hping3, and Social Engineering Toolkit.

10 open source tools that feel illegal...

Provides a readily available platform and suite of tools for penetration testing and security analysis.

Explore Kali Linux and its pre-installed tools to understand their capabilities and potential applications in security assessments.


Hostinger offers VPS hosting with features like NVMe SSD storage, AMD epic chips, Docker manager, and one-click Superbase deployment.

Provides a platform for running Kali Linux or other security tools in a virtualized environment.

Evaluate Hostinger's VPS offerings for penetration testing and security research, considering its performance and ease of use.


Nmap is a network mapping tool that identifies open ports and operating systems to find potential vulnerabilities.

Enables discovery of network services and potential attack vectors.

Learn to use Nmap for network reconnaissance and vulnerability scanning.


Wireshark is a packet analyzer that allows inspection of network traffic at a microscopic level.

Provides deep insights into network communications and potential security breaches.

Study Wireshark to analyze network traffic and identify suspicious activity.


Metasploit is a powerful hacking framework that allows launching attacks using exploits like Eternal Blue.

Simplifies the process of exploiting vulnerabilities, but may hinder learning opportunities.

Use Metasploit to understand exploit development and penetration testing, but also explore manual techniques for a deeper understanding.


Aircrack is a tool for cracking Wi-Fi protected access keys and intercepting network packets.

Highlights the importance of using HTTPS and strong encryption for sensitive data.

Use Aircrack in a controlled environment to understand Wi-Fi security vulnerabilities and implement stronger security measures.


Hashcat is a password cracking tool that can be used to crack hashed passwords using various techniques like brute force and dictionary attacks.

Demonstrates the importance of using strong passwords and multi-factor authentication.

Experiment with Hashcat to understand password cracking techniques and improve password security practices.


Skipfish is a web application vulnerability scanner that crawls websites and identifies vulnerabilities like cross-site scripting and SQL injection.

Enables discovery of web application vulnerabilities and potential attack vectors.

Use Skipfish to scan web applications for vulnerabilities and implement appropriate security measures.


Foremost is a forensic data recovery tool that can recover deleted files from hard drives.

Highlights the importance of secure data deletion and disk wiping techniques.

Explore Foremost to understand data recovery techniques and implement secure data deletion practices.


SQLmap is a tool for scanning websites and servers to find databases and launch SQL injection attacks.

Enables discovery of database vulnerabilities and potential data breaches.

Use SQLmap to identify SQL injection vulnerabilities and implement appropriate security measures.


hping3 is a tool for sending packets to an IP address as fast as possible, which can be used for denial-of-service attacks.

Demonstrates the potential for denial-of-service attacks and the importance of implementing DDoS mitigation strategies.

Use hping3 in a controlled environment to understand denial-of-service attacks and implement appropriate mitigation strategies.


Social Engineering Toolkit allows creating sophisticated phishing attacks using various attack vectors.

Highlights the importance of user awareness training and security protocols to prevent phishing attacks.

Use Social Engineering Toolkit to simulate phishing attacks and train users to identify and avoid them.


LLMs have plateaued and are not showing exponential leaps in intelligence.

Indicates a need to explore alternative AI architectures or enhancements to LLMs to achieve true self-improving AI.

Research and experiment with AI architectures beyond LLMs, focusing on self-improvement and continuous learning capabilities. Investigate techniques like reinforcement learning, evolutionary algorithms, or hybrid models.


AI coding tools are creating a new job market for 'code janitors' to clean up AI-generated garbage code.

Highlights a potential market opportunity for tools and services that automatically improve and refactor AI-generated code.

Explore the development of automated code quality tools specifically designed to address the shortcomings of AI-generated code. Focus on areas like bug detection, code style enforcement, and performance optimization.


SpaceX, OpenAI, and Anthropic are likely to IPO in 2026.

Indicates a potential shift in the AI landscape as these companies become publicly traded and subject to market scrutiny.

Monitor the IPO filings and performance of SpaceX, OpenAI, and Anthropic to gain insights into their business models, growth strategies, and competitive positioning. Analyze their financial reports and investor presentations.


Companies like Google and Nvidia are providing the base technology for humanoid robots, enabling easier development and fundraising.

Suggests a growing ecosystem around humanoid robot development, with opportunities for companies providing enabling technologies and services.

Investigate the technologies and platforms offered by Google and Nvidia for humanoid robot development. Explore potential partnerships or integrations to leverage these technologies.


OpenAI is collaborating with Johnny IV to create a better wearable AI device.

Highlights a potential competitor in the wearable AI space with significant resources and expertise.

Monitor the development and release of the OpenAI/Johnny IV wearable AI device. Analyze its features, functionality, and target market to assess its competitive threat.


Quantum computing is advancing and may surpass supercomputers, potentially disrupting the AI landscape.

Indicates a long-term threat to current AI approaches and a potential opportunity to leverage quantum computing for AI applications.

Track advancements in quantum computing and its potential applications in AI. Invest in research and development to explore quantum machine learning algorithms and architectures.


Bun.js is a JavaScript runtime with built-in support for Postgres and Redis, making it a tempting choice for new projects.

Suggests a potential shift in the JavaScript runtime landscape and a need to evaluate Bun.js for new projects.

Evaluate Bun.js for new JavaScript projects, focusing on its performance, ease of use, and integration with Postgres and Redis. Compare it to existing runtimes like Node.js and Deno.


OpenClaw, a JavaScript AI wrapper, was acquired by OpenAI after a rapid rise to 200,000 GitHub stars.

When open-sourcing your code goes wrong...

Demonstrates the potential for rapid growth and acquisition in the AI space, even for relatively simple tools.

Monitor similar rapid-growth AI projects for potential acquisition targets or competitive threats.


Faker.js developer deleted the source code in protest of unpaid work, highlighting the challenges of maintaining open-source projects without adequate compensation.

Illustrates the risk of relying on open-source projects maintained by individuals who may become disillusioned.

When using open-source libraries, assess the project's sustainability and consider contributing financially or through code contributions.


Facebook acquired Pars, a backend-as-a-service, but later shut it down, forcing developers to migrate.

Highlights the risk of relying on services owned by large corporations that may change their priorities.

Diversify dependencies and have a migration plan in place for critical services.


Meteor, a full-stack JavaScript framework, failed due to scalability issues and the rise of React and Angular.

Demonstrates the importance of scalability and adaptability in software frameworks.

Prioritize scalability and maintainability when choosing or developing frameworks.


OpenSolaris, a technically superior OS, failed after Oracle acquired Sun Microsystems and stopped open development.

Highlights the risk of relying on open-source projects controlled by companies that may change their strategy.

Assess the ownership and governance of open-source projects before adopting them.


Mozilla Firefox, despite being open-source and technically superior, initially lost the browser war to Internet Explorer due to Microsoft's platform control and distribution.

Demonstrates that technical superiority and open-source development are not always sufficient to overcome platform control and distribution advantages.

Consider distribution strategies and platform dependencies when developing open-source projects.


Code Rabbit offers customizable AI code review summaries, saving development teams time.

Illustrates the potential of AI-powered tools to improve developer productivity.

Evaluate Code Rabbit and similar AI code review tools for potential adoption.


Code Rabbit allows customization of AI code reviewer to include specific information like branching changes and new dependencies.

Shows the value of customizable AI tools that can be tailored to specific team needs and workflows.

When evaluating AI tools, prioritize those that offer customization options.


JetBrains' Juny AI coding agent is built directly into the JetBrains IDE, allowing it to understand the structure and history of the entire codebase.

Improved context and accuracy in code generation compared to other tools.

Investigate JetBrains' Juny and its integration with JetBrains IDEs. Evaluate its ability to leverage codebase history for improved code generation and context understanding.


Juny's ability to understand the structure and history of the entire codebase suggests a persistent context mechanism, potentially leveraging RAG or similar techniques.

Enables more accurate and context-aware code generation and suggestions.

Research the underlying architecture of Juny to understand how it maintains and utilizes codebase context. Explore the use of RAG or similar techniques for persistent context in code generation.


Juny has built-in AI chat for asking deeper questions about the code it's writing and the logic behind it.

Facilitates understanding and debugging of AI-generated code.

Analyze the capabilities of Juny's AI chat feature. Evaluate its effectiveness in explaining code logic and assisting with debugging.


Juny supports Grock, Gemini, and other major coding models.

Provides flexibility and access to different AI coding models.

Compare the performance of Juny with different coding models (Grock, Gemini, etc.) to identify the best model for specific tasks and coding styles.


Allows for risk-free evaluation of the tool's capabilities.

Sign up for the free trial of Juny and evaluate its performance on various coding tasks. Assess its context understanding, accuracy, and overall usability.


Juny is positioned as being slower than other codegen tools but better at context and accuracy.

Highlights a trade-off between speed and quality in AI code generation.

Benchmark Juny against other AI code generation tools, specifically measuring code generation speed, accuracy, and context understanding. Quantify the trade-off between speed and quality.


OpenClaw (formerly Claudebot/Maltbot) is a free and open-source AI assistant written in Typescript that wraps Claude and GPT5.

Provides a self-hosted alternative to paid AI assistants and allows for greater control and customization.

Evaluate OpenClaw for potential use cases and contributions to the open-source project.


OpenClaw can be self-hosted on a VPS, Raspberry Pi, or Mac Mini.

Reduces reliance on third-party services and provides greater data privacy.

Investigate the resource requirements and setup process for self-hosting OpenClaw.


OpenClaw uses hooks to tap into lifecycle events, allowing it to keep memories and trigger follow-up automations.

Enables persistent context and more sophisticated automation workflows.

Explore the available hooks and their capabilities for building custom automations.


OpenClaw allows users to bring their own skills and uses MoltHub for pre-built skills.

Extends the functionality of the AI assistant and allows for customization to specific needs.

Investigate MoltHub and identify relevant skills for potential use cases. Consider developing custom skills.


OpenClaw integrates with messenger apps like Telegram, Slack, WhatsApp, and Discord.

Provides a convenient and accessible interface for interacting with the AI assistant.

Evaluate the integration with different messenger apps and choose the most suitable option.


OpenClaw can be used to automate tasks such as managing calendars, cleaning up email, running scripts, and tracking investments.

Increases productivity and reduces the need for manual intervention.

Identify specific tasks that can be automated with OpenClaw and implement the necessary configurations.


OpenClaw can be configured to refine its personality through chat interactions.

Allows for customization of the AI assistant's behavior and communication style.

Experiment with different personality configurations to optimize the AI assistant's performance.


Anthropic threatened legal action against the original name 'Claudebot' due to similarity to their product 'Claude'.

Highlights the competitive landscape and the importance of trademark considerations in the AI space.

Be mindful of trademark issues when naming new AI projects or products. Conduct thorough trademark searches.


The video mentions Tracer, an agent orchestration layer that helps coding agents build real-world software.

Introduces a tool for improving the performance of coding agents.

Explore Tracer's features and capabilities, particularly its 'epic mode' and 'Bart Simpson' orchestration system.


Tracer uses a smart orchestration system called Bart Simpson that tracks what's actually happening under the hood and corrects agents the moment they drift.

Improves the reliability and efficiency of coding agents.

Investigate the Bart Simpson orchestration system and its potential applications for other AI agent workflows.


The video implies that paying $29/month for a similar service is unnecessary due to the availability of OpenClaw.

Positions OpenClaw as a cost-effective alternative to commercial AI assistants.

Compare the features and capabilities of OpenClaw with paid AI assistant services to determine its value proposition.


Gemini 3.1 Pro significantly outperforms Gemini 3 Pro and competes with Opus 4.6 on benchmarks like ARC AGI 2, GPQA Diamond, and SWEBench.

Indicates advancements in reasoning, knowledge, and coding abilities.

Evaluate Gemini 3.1 Pro for specific use cases and compare its performance against Opus 4.6 and other leading models.


Gemini 3.1 Pro excels at generating animated SVGs, showcasing improved visual design and detail creation capabilities.

Highlights potential for creative applications and content generation.

Explore Gemini 3.1 Pro's SVG generation capabilities for marketing materials, educational content, or other visual applications.


Gemini 3.1 Pro can simulate complex systems like bird flocking (murmuring) and urban planning.

Demonstrates advanced simulation and modeling capabilities.

Investigate Gemini 3.1 Pro's simulation capabilities for specific industry applications, such as logistics, traffic management, or environmental modeling.


Gemini 3.1 Pro can generate CAD models from technical drawings, enabling prompt-based 3D printing.

Opens up possibilities for rapid prototyping and customized manufacturing.

Test Gemini 3.1 Pro's CAD modeling capabilities for specific product design and 3D printing applications.


Anthropic's Sonnet 4.6 is a strong performer for knowledge work and tool calling, but is expensive.

Highlights a trade-off between performance and cost for different models.

Evaluate Sonnet 4.6 for tasks requiring strong tool calling and knowledge work, considering its cost compared to other models.


ARC AGI 2 benchmark tests a model's ability to acquire new skills through learning and generalize them quickly.

Indicates the model's adaptability and potential for continuous learning.

Track performance on ARC AGI 2 as a key metric for evaluating the self-improving capabilities of AI models.


Gemini 3.1 Pro is being integrated across Google's consumer and developer products.

Widespread availability and potential for integration into existing workflows.

Monitor Google's product updates and developer resources to identify opportunities for leveraging Gemini 3.1 Pro in existing applications.


Coinbase's X42 protocol enables micro-payments for APIs with zero fees, potentially revolutionizing machine-to-machine payments and AI agent interactions.

Significant potential to reduce transaction costs and friction for AI agents interacting with paid APIs.

Investigate X42 protocol and its potential applications for AI agent-based services and micro-transactions.


X42 simplifies API monetization by using HTTP 402 (Payment Required) status code and wallet integration, eliminating the need for subscriptions and complex authentication.

Reduces complexity and overhead for monetizing APIs, making it easier for developers to implement paywalls.

Evaluate X42 as a simpler alternative to existing payment solutions like Stripe for API monetization.


X42 SDK provides middleware for Node.js to easily implement paywalls for API endpoints with minimal code.

Accelerates the development and deployment of monetized APIs.

Explore the X42 SDK and its capabilities for integrating payment functionality into existing and new APIs.


X42 fetch library allows AI agents to programmatically handle payment requests for paid APIs.

Enables autonomous AI agents to access and pay for resources programmatically, fostering an AI economy.

Investigate the X42 fetch library and its capabilities for AI agent integration.


Hostinger offers virtual private servers (VPS) with Docker Compose Manager for deploying and managing containerized applications.

Provides a cost-effective and streamlined infrastructure for running AI agent-based services.

Evaluate Hostinger VPS as a potential hosting solution for AI agent deployments, focusing on Docker Compose Manager features.


Stripe charges a 30 cent fee per transaction, making it unsuitable for micro-payments.

Highlights the limitations of existing payment platforms for micro-transactions and the need for alternative solutions like X42.

Compare the cost-effectiveness of X42 with Stripe and other payment platforms for micro-payment scenarios.


The video mentions the possibility of AI agents paying each other for services, creating an AI economy.

This highlights a potential future where AI agents are autonomous economic actors.

Explore the potential implications of an AI economy and the role of micro-payment systems like X42 in facilitating it.


The video demonstrates a simple API that provides esoteric knowledge for a Bitcoin payment, showcasing the potential for monetizing information and services.

Illustrates a use case for micro-payments in accessing valuable information or services.

Brainstorm potential use cases for monetizing information and services through micro-payments, particularly in the context of AI agents.


OpenAI's Codeex app (command center for agents) allows non-developers to build apps, potentially reducing the need for developer seats.

How AI is breaking the SaaS business model...

Reduced demand for developer seats in SaaS platforms.

Explore no-code/low-code AI agent platforms like Codeex to understand their capabilities and potential impact on developer roles.


OpenAI's Codeex 5.3 model integrates skills like image generation, writing, and research, potentially replacing entire product development teams.

Consolidation of roles and reduced headcount in product development.

Evaluate the capabilities of Codeex 5.3 and similar models to identify tasks that can be automated or augmented.


Anthropic's Claude Opus 4.6 is expanding beyond code generation into legal analysis and financial modeling to justify enterprise subscriptions.

AI models are becoming more versatile and targeting higher-value enterprise use cases.

Monitor Claude Opus 4.6's capabilities in legal and financial domains to assess its potential impact on those industries.


Alibaba's Quen 3 Coder Next is an open-weight coding model that can be self-hosted, eliminating vendor lock-in and reducing reliance on SaaS dev tools.

Shift towards self-hosted AI solutions and reduced dependence on SaaS vendors.

Investigate Quen 3 Coder Next and other open-source coding models to evaluate their suitability for self-hosting and internal development.


ZAI's GLM5 targets complex systems engineering and long horizon agentic jobs, rivaling closed models.

Open-source models are becoming competitive with closed-source models in complex domains.

Evaluate GLM5's performance in systems engineering and long-horizon tasks to assess its potential for adoption.


Miniax M2.5 offers top-tier reasoning at a fraction of the compute cost, making $200 AI plans obsolete.

Decreasing cost of AI inference and increased accessibility to advanced AI capabilities.

Explore Miniax M2.5 and other cost-effective AI models to identify opportunities for reducing AI infrastructure costs.


Microsoft's GitHub agent HQ is an AI agent orchestration platform for code hosting, project management, QA, and DevOps automation.

Consolidation of development workflows into AI-powered orchestration platforms.

Investigate GitHub agent HQ to understand its capabilities and potential for streamlining development processes.


Whimo's world model demonstrates how AI systems can model complex environments, make decisions, and act autonomously, potentially replacing traditional SaaS dashboards.

AI-powered simulation and prediction models are disrupting traditional SaaS dashboards.

Explore Whimo's world model and similar technologies to identify opportunities for incorporating AI-powered simulation and prediction into business software.


Warp's Oz platform allows running hundreds of coding agents in the cloud, enabling parallel execution of tasks across multiple repositories.

Scalable AI agent platforms are enabling parallel automation of development tasks.

Evaluate Warp's Oz platform to assess its suitability for automating development tasks and improving developer productivity.


The shift from per-seat pricing to intelligence-based pricing is predicted to disrupt the SaaS business model.

SaaS companies need to adapt their pricing models to reflect the value of AI-driven automation.

Analyze current SaaS pricing models and explore alternative models based on usage, outcomes, or AI-driven value.


Anthropic acquired Bun, a JavaScript and TypeScript toolkit, likely to power Claude Code and future AI products due to its speed and predictability.

Anthropic just bought your favorite JS runtime...

Bun's development may be influenced by Anthropic's needs, potentially prioritizing AI-related features.

Monitor Bun's development roadmap for AI-specific features and potential changes in direction.


Bun's ability to compile apps into single executables makes it suitable for building CLIs, which Anthropic uses for Claude Code.

This highlights the importance of efficient and portable execution environments for AI agents.

Investigate Bun's CLI capabilities and explore its potential for deploying AI agents.


The acquisition suggests a trend towards AI companies investing in infrastructure that provides fast and predictable execution environments for AI agents.

This indicates a growing need for optimized runtimes and tooling for AI development and deployment.

Research and evaluate other high-performance runtimes and frameworks suitable for AI agents.


Bun's open-source status is uncertain after the acquisition, as Anthropic doesn't have a strong track record with open-source projects.

The community may need to fork Bun if Anthropic changes its licensing or development practices.

Monitor the Bun community and Anthropic's communication regarding Bun's open-source status.


Bun is described as an 'all-in-one' bundler, transpiler, runtime, test runner, and package manager, indicating a trend towards integrated development tools.

Integrated tools can streamline development workflows and improve developer productivity.

Evaluate the benefits of using all-in-one tools like Bun compared to specialized tools.


The acquisition highlights the value of developer tools that improve build times and overall JavaScript ecosystem performance.

Faster development cycles can lead to quicker iteration and innovation in AI development.

Prioritize tools and techniques that optimize build times and improve development efficiency.


Gemini 3 Pro replaced Claude in AMP's coding agent due to superior performance.

Shows Gemini 3 Pro's strong performance and potential for adoption in real-world applications.

Evaluate Gemini 3 Pro for coding agent tasks and compare its performance to other models like Claude.


Google released Anti-Gravity, a VS Code fork designed for agentic coding with Gemini, stemming from the Windserve acquisition.

Highlights Google's focus on agentic development and the integration of AI into coding workflows.

Investigate Anti-Gravity's features and capabilities for agentic coding and compare it to other IDEs.


Anti-Gravity is an agentic development platform where users are 'managers of agents'.

Indicates a multi-agent coordination paradigm where users orchestrate AI agents for development tasks.

Research the architecture and workflow of Anti-Gravity to understand how users manage and coordinate AI agents.


Windsurf's coding agent 'Cascade' is integrated into Anti-Gravity.

Suggests a potential reuse of existing agentic technology within the new platform.

Investigate Cascade's capabilities within Anti-Gravity to understand its role in the agentic development workflow.


Chad, a brain-rot IDE backed by Y Combinator, integrates brain-rot devices directly into the agentic coding workflow.

Highlights a competitor in the agentic coding space with a unique (though satirical) approach to integration.

Monitor Chad's development and user adoption to assess its potential impact on the agentic coding market.


Google's IDX editor is now Firebase Studio, accelerating development with AI agents.

Shows Google's continued investment in AI-powered development tools and their integration into existing platforms.

Explore Firebase Studio's AI agent capabilities and assess its suitability for different development workflows.


Google's Jules is an autonomous coding agent.

Indicates the existence of a separate autonomous coding agent within Google's ecosystem.

Research Jules' capabilities and compare it to other coding agents like Cascade and those in Firebase Studio.


Mobin.com provides detailed breakdowns of UI elements and user journeys for popular applications, which can be copied into Figma.

Highlights a tool for UI/UX analysis and design inspiration that can be integrated into development workflows.

Explore Mobin.com's features and assess its usefulness for UI/UX design and development.


GenSpark is an all-in-one AI workspace that orchestrates multiple AI models to get work done faster.

React.js shell shocked by 10.0 critical vulnerability…

Provides a centralized platform for utilizing multiple AI models, potentially increasing developer productivity.

Investigate GenSpark's capabilities and pricing to determine if it aligns with development needs and budget.


GenSpark allows developers to build landing pages and full-stack web apps in a browser-based dev environment and deploy them on Cloudflare.

Offers a streamlined development and deployment workflow, potentially reducing time to market.

Evaluate GenSpark's development environment and Cloudflare integration to assess its suitability for specific projects.


GenSpark can connect to external services like Slack and Google Drive to automate tasks and act as a central hub for work.

Enables automation of workflows and integration with existing tools, potentially improving efficiency and collaboration.

Explore GenSpark's integration capabilities and identify potential use cases for automating tasks and connecting to existing workflows.


GenSpark orchestrates multiple AI models to produce highly polished output.

Suggests a multi-agent system where different AI models contribute to a final result.

Research GenSpark's architecture to understand how it orchestrates multiple AI models and the benefits of this approach.


GenSpark is presented as a solution to the problem of manually bouncing between different AI models (Gemini 3, Nano Banana, Sonnet 4.5).

Highlights a competitive advantage of GenSpark: simplifying the use of multiple AI models.

Compare GenSpark's ease of use and AI model integration with other AI platforms and tools.


Recursive Language Models (RLMs) are presented as an inference strategy where a language model controls the calling of other language models, treating them as functions with more flexibility.

2025 10 31 Recursive Language Models w Alex Zhang

Potential to overcome limitations of single model calls, such as context length restrictions and performance degradation in long contexts.

Explore RLMs as a potential architecture for handling long context tasks and improving language model performance.


RLMs aim to provide the illusion of near-infinite context without degradation by offloading tasks from the main language model call, similar to virtual memory.

Could significantly improve the ability of language models to process and reason over large amounts of information.

Investigate techniques for offloading context management and processing in language models, drawing inspiration from virtual memory concepts.


RLMs are positioned as a bet on the bitter lesson, aiming to defer context management, sub-model calling, and tool use to the language model itself, allowing for optimization through RL or SFT.

Potential to create more general and adaptable language models that can handle a wider range of tasks without requiring task-specific scaffolding.

Research methods for training language models to manage context, call sub-models, and use tools autonomously, focusing on RL and SFT techniques.


The speaker suggests that RLMs can be optimized for specific functionalities (context management, tool use) through RL or SFT, treating the RLM as a language model from the user's perspective but leveraging its internal structure for training.

This approach could lead to more efficient and effective training of language models for complex tasks.

Experiment with RL and SFT techniques to optimize RLMs for specific functionalities, such as context management and tool use.


The speaker highlights the use of a ripple environment (code execution environment) as a context container for RLMs, allowing the language model to interact with and transform the context through code.

Provides a flexible and powerful way for language models to process and reason over complex data.

Explore the use of ripple environments or similar code execution environments as context containers for language models.


Experiments with RLMs using GPT5 mini on the ulong benchmark showed a doubling of performance compared to GPT5, with comparable or cheaper API costs.

Demonstrates the potential of RLMs to significantly improve language model performance and efficiency.

Replicate and extend the experiments on the ulong benchmark to further validate the effectiveness of RLMs.


Recursive Language Models (RLMs) are presented as an inference strategy where a language model controls calling other language models, offering flexibility beyond treating a language model as a black box function.

2026 02 26 recursive language models w alex zhang

RLMs could overcome limitations of single model calls and fixed context windows, potentially leading to more capable and scalable AI systems.

Investigate RLMs as a potential architecture for Genesis AI to handle long context tasks and complex reasoning.


RLMs aim to provide the illusion of near-infinite context without degradation by offloading context management to the language model itself, similar to virtual memory.

This could significantly improve performance on long context tasks and reduce context rot, a common problem with current language models.

Explore techniques for offloading context management in Genesis AI, potentially using a virtual memory-like system.


The speaker frames RLMs as a bet on the bitter lesson, suggesting that complex human-engineered agent scaffolds should be replaced by a more general, trainable system.

This could lead to more adaptable and robust AI agents that can generalize to new tasks without requiring significant modifications to the underlying architecture.

Prioritize developing a general-purpose RLM framework that can be optimized through RL or SFT, rather than building task-specific agent scaffolds.


The speaker emphasizes the importance of the environment in which the language model operates, suggesting that a ripple environment (code execution environment) is particularly effective for managing context and enabling flexible reasoning.

This could allow language models to interact with and manipulate data in a more natural and efficient way, leading to improved performance on complex tasks.

Evaluate the feasibility of integrating a ripple-like environment into Genesis AI to enable code-based context management and reasoning.


The speaker mentions experiments using GPT-5 mini within an RLM framework, achieving performance comparable to or better than GPT-5 at a similar or lower cost on the ulong benchmark.

This suggests that RLMs can significantly improve the efficiency and effectiveness of language models on long context tasks.

Benchmark Genesis AI against GPT-5 and other state-of-the-art models on long context tasks, using an RLM framework to improve performance and reduce costs.


The speaker highlights that not all long context tasks are retrieval tasks, and that RLMs can be effective in situations where retrieval-based approaches are not suitable.

This suggests that RLMs can be a valuable tool for a wider range of tasks than traditional retrieval-based approaches.

Explore the use of RLMs for tasks that require complex reasoning and manipulation of information, rather than simple retrieval.


The speaker mentions the browse comp plus benchmark, an offline multihop retrieval problem, as a potential area for further experimentation with RLMs.

This could provide insights into the effectiveness of RLMs for complex information retrieval tasks.

Evaluate Genesis AI on the browse comp plus benchmark, using an RLM framework to improve performance.


The speaker suggests that language models should be trained to be better at using a fixed, common scaffold, potentially through RL or SFT.

This could lead to more efficient and effective training of language models for specific tasks.

Explore the use of RL and SFT to train Genesis AI to effectively utilize a fixed RLM scaffold.


The speaker views the context as a game-like memory that the language model can poke at and transform through recursive sub-calls.

This perspective could lead to new approaches for managing and manipulating context in language models.

Investigate the use of game-theoretic techniques to optimize context management in Genesis AI.