David Ondrej · Published 2026-10-02

Vercel CEO reveals his Agentic Engineering Workflow

privateReview: unreviewedConfidence: high
agentssecuritysupabasevercelinfrastructureSandboxingsupply-chain-securityagent-harnessrow-level-securitybenchmarkingvulnerability-scanninginference-decouplingagentic-infrastructure
Open on YouTube ↗

Summary

Overview

  • Speaker: Guillermo Rauch
  • Channel: David Ondrej
  • Main topic: Agentic Engineering Workflow and AI Software Development
  • Purpose: To explore how AI agents are transforming software engineering workflows, infrastructure, security, and developer productivity. Guillermo Rauch discusses the evolution of software engineering in the post-AGI era, highlighting the security debt of human-written code, the shift toward sandboxes, and the importance of human control in creative and cybersecurity risk management. He shares insights on Supabase, Vercel's internal AI tools like Fx and Cloudroom, and the economic tradeoffs of running software agents at scale.

Topic Map

Security Debt in Human-Written Code

  • Explanation: Discusses how human-written code carries massive latent vulnerabilities and supply chain risks that can be mitigated by moving development cycles to sandboxes.
  • Key claims:
    • The surface of attack for AI and traditional software has expanded massively.
    • Human-written code contains unmeasurable latent vulnerabilities.
    • Moving development to sandboxes can eradicate supply chain attacks.
  • Examples:
    • AI prompt injections and training attacks.
    • Sandboxed containers isolating app kernels from host kernels.
  • Terminology:
    • security debt
    • surface of attack
    • sandboxes
    • supply chain attacks
  • Why it matters: Security debt is one of the biggest challenges in adopting new software and AI development tools.

Human Control in the Post-AGI Era

  • Explanation: Emphasizes that maintaining human control over creative decisions, cybersecurity risks, and agent orchestration is paramount.
  • Key claims:
    • The most critical factor in the post-AGI era is human ability to stay in control.
    • Creative control and risk management remain uniquely human domains.
  • Examples:
    • Harness engineering and software factories orchestrating fleets of agents.
  • Terminology:
    • creative control
    • harness engineering
    • software factory
    • agent orchestration
  • Why it matters: Ensures humans guide the direction and safety of automated software development.

Supabase as the Ultimate Backend for AI Agents

  • Explanation: Explores why Supabase is the preferred backend for AI agents due to its relational database power, built-in Row Level Security, and native agent integration.
  • Key claims:
    • Supabase provides a scalable, agent-first backend for modern applications.
    • AI agents can build entire backends because Supabase works inside ChatGPT and Claude.
  • Examples:
    • Stripe Subscriptions Starter and Next.js App Router templates powered by Supabase.
  • Terminology:
    • Supabase
    • Row Level Security
    • PostgreSQL
    • agent-first
  • Why it matters: Simplifies backend database setup, authentication, and security for AI-generated applications.

Cloudroom: Open Source Cloud Agents Platform

  • Explanation: Introduces Cloudroom as the first open-source platform for running cloud agents, contrasting it with closed alternatives.
  • Key claims:
    • Cloudroom gives each agent its own cloud computer in an open-source ecosystem.
    • Developers paying for inference should be able to use their favorite models and harnesses.
  • Examples:
    • Running Devin, Cursor, Codex, and Claude agents on Cloudroom.
  • Terminology:
    • Cloudroom
    • cloud agents
    • open-source platform
    • inference
  • Why it matters: Provides an open and flexible alternative to closed, proprietary cloud agent systems.

Vercel's Fx CLI and Agentic Infrastructure

  • Explanation: Demonstrates Fx, Vercel's tiny, binary CLI coding agent that lives in the terminal and runs Node.js/Next.js applications seamlessly.
  • Key claims:
    • Fx acts as a coding agent in the terminal with extremely fast startup times.
    • Agentic infrastructure allows agents to read codebases, run tools, and ship verified changes.
  • Examples:
    • Building landing pages and pixel-art scenes using Fx with Claude Opus 5.5.
  • Terminology:
    • Fx
    • CLI coding agent
    • terminal
    • Vercel Sandbox
    • agentic infrastructure
  • Why it matters: Presents a new paradigm of software development where agents drive the implementation experience.

Deepsec and Cybersecurity for AI Codebases

  • Explanation: Examines Deepsec, Vercel's cybersecurity harness designed to scan repositories for vulnerabilities using state-of-the-art models.
  • Key claims:
    • Deepsec uncovers vulnerabilities across codebases by deep-scanning with latest models.
    • Open-source libraries like libheif have historically suffered from remote code execution vulnerabilities.
  • Examples:
    • Deepsecbench evaluating AI model performance on security vulnerability detection.
  • Terminology:
    • Deepsec
    • Deepsecbench
    • cybersecurity harness
    • vulnerability scanning
    • libheif
  • Why it matters: Highlights the critical need for proactive security measures as AI agents generate more code.

Key Points

The Analogy of Farming vs. Software

  • Explanation: Farming was once done by 90% of the population, but automation reduced it to under 1%. Similarly, filling out forms and writing boilerplate code will be automated by AI agents.
  • Evidence: Percentage of human population in food production over time chart.
  • Practical implication: Engineers will transition from manual coding to managing fleets of AI agents and setting high-level architectures.

Iteration Velocity vs. Iteration Speed

  • Explanation: Iteration speed is how fast you output code, but iteration velocity measures speed combined with correct direction and goal alignment.
  • Evidence: Discussion on token maxing and PR landing rates.
  • Practical implication: Moving fast without proper direction leads to building the wrong product efficiently.

Secure Code by Construction

  • Explanation: Relying solely on unit tests after writing insecure code is insufficient. Infrastructure must be secure by construction.
  • Evidence: Discussion on moving C libraries into memory-safe languages like Rust.
  • Practical implication: Enterprises must adopt secure cloud environments and automated vulnerability scanners like Deepsec.

Frameworks, Models & Processes

Agentic Inquiry Framework

  • How it works: An agent experiments with a technology, reflects on its performance, and provides actionable feedback on what could be done better.
  • Components:
    • Experimentation
    • Execution
    • Reflection
    • Improvement
  • When to use: When evaluating new AI models, CLI tools, or infrastructure components.

Verification Engineering

  • How it works: Establishing guardrails, axioms, and proof systems around AI agents to ensure code correctness and safety.
  • Components:
    • Guardrails
    • Axioms
    • Trade-offs
    • Automated Scans
  • When to use: When deploying autonomous coding agents in production environments.

Examples & Case Studies

Building a pixel-art dinosaur animation using Fx with Claude Opus 5.5.

  • Illustrates: The creative and visual capabilities of modern CLI coding agents.
  • Lesson: AI models can rapidly generate complex graphical and animated scenes from simple text prompts.

Deepsec uncovering authentication vulnerabilities in Artifactory (CVE-2026-82329).

  • Illustrates: The effectiveness of AI agents in finding critical zero-day security flaws.
  • Lesson: Automated security scanners can discover severe vulnerabilities in complex software ecosystems.

Actionable Takeaways

  • Immediate:
    • Try Supabase for instant, scalable, agent-first backend setups.
    • Use Vercel's Fx CLI agent for rapid terminal-based software prototyping.
  • Strategic:
    • Shift software development lifecycles into secure sandboxed containers.
    • Adopt verification engineering and automated security scanners like Deepsec to manage security debt.
  • Questions to investigate:
    • How will enterprise security policies evolve as autonomous agents write production code?
    • What is the optimal balance between human oversight and agent autonomy in software factories?

Claims Worth Verifying

  • Supabase works natively inside ChatGPT and Claude via official connectors. (technical)
  • Fx is a binary CLI agent of 6MB that boots instantly in the terminal. (technical)

Notable Quotes

"One of my biggest challenges today in adopting new software, both personally and at Vercel, is understanding the security debt that I'm taking on." (at 0:00) "I build software to relax. I build software for work, and then I go home and I build more software." (at 3:41) "Supabase handles all of that for you. With their official connector, you can just ask Codex or Claude Code to use it." (at 8:21) "The coding agent that lives in your terminal. Fx reads your codebase, runs your tools, and ships verified changes without leaving the shell." (at 40:27)

Compressed Summary

  • Security debt is a major challenge in modern software adoption.
  • Supabase offers an agent-first, scalable backend with Row Level Security.
  • Cloudroom provides an open-source platform for running cloud agents.
  • Vercel's Fx CLI agent brings rapid, terminal-based app generation.
  • Deepsec enables deep vulnerability scanning across complex codebases.
  • Keywords: agents, security, supabase, vercel, infrastructure
  • Core insight: Agentic engineering shifts developers from manual coding to orchestrating verified AI workflows within secure sandboxed infrastructure.

Core insights

6
Architecturehigh noveltymoderate evidence

Rather than relying on post-hoc testing of code that is already insecure, security must be a property of the execution environment: running development cycles inside sandboxed containers whose app kernel is isolated from the host kernel, with the claim that this can eradicate supply chain attacks.

Why it matters

Moves the security boundary from the code artifact (unit tests, reviews, scanners) to the runtime substrate, which changes where an agent harness must execute and what the host must expose to it.

Generalization

Any agentic coding system that executes model-generated code should treat the execution sandbox, not the generated artifact, as the primary trust boundary; 'secure by construction' becomes a property of the runtime, not of the review process.

Relying solely on unit tests after writing insecure code is insufficient. Infrastructure must be secure by construction.
Open source video
Moving development to sandboxes can eradicate supply chain attacks.
Open source video
Sandboxed containers isolating app kernels from host kernels.
Open source video
Architecturehigh noveltymoderate evidence

The paid inference layer should be decoupled from the agent harness and model choice: an open-source cloud-agent platform gives each agent its own cloud computer so teams can run their preferred models and harnesses (Devin, Cursor, Codex, Claude) on infrastructure they pay for.

Why it matters

Splits the agent stack into swap-able layers (compute sandbox, harness, model) instead of vertically integrated closed platforms, which affects lock-in, cost routing, and where evaluation can be performed independently of the vendor.

Generalization

Agent infrastructure should expose the per-agent compute unit as the stable interface, letting harness and model be replaced without re-architecting the runtime.

Cloudroom gives each agent its own cloud computer in an open-source ecosystem.
Open source video
Developers paying for inference should be able to use their favorite models and harnesses.
Open source video
Practicemedium noveltymoderate evidence

Correctness for autonomous coding agents is framed as a verification problem with an explicit verification stack (guardrails, axioms, trade-offs, automated scans) rather than as a prompting or capability problem.

Why it matters

Implies that harness design effort should be allocated to proof/guardrail scaffolding and automated scanning around the agent, not only to model selection, since code correctness is enforced outside the model.

Generalization

Production agent deployments need an explicit verification layer whose components (axioms, guardrails, scanners) are versioned and tested like the code they protect.

Establishing guardrails, axioms, and proof systems around AI agents to ensure code correctness and safety.
Open source video
Automated Scans
Open source video
Mental Modelmedium noveltymoderate evidence

Iteration speed is distinguished from iteration velocity: velocity combines output rate with correct direction and goal alignment, so token throughput and PR landing rates can be high while the system builds the wrong product efficiently.

Why it matters

Gives a metric framing that separates throughput instrumentation (tokens, PRs) from alignment instrumentation, warning that token-maxing optimizes the wrong variable.

Generalization

Any agentic delivery pipeline should be measured on landed, direction-correct changes rather than generation volume; volume-only metrics are actively misleading.

Iteration speed is how fast you output code, but iteration velocity measures speed combined with correct direction and goal alignment.
Open source video
Moving fast without proper direction leads to building the wrong product efficiently.
Open source video
Discussion on token maxing and PR landing rates.
Open source video
Architecturehigh noveltyweak evidence

An agent-first backend is one the agent can reach from inside the model runtime it already lives in: Supabase is positioned as agent-friendly because it works inside ChatGPT and Claude and carries Row Level Security, letting agents construct entire backends including auth and data protection.

Why it matters

Puts the authorization boundary in the data layer (RLS) rather than in agent-authored application code, which is where generated code is least trustworthy.

Generalization

For agent-generated applications, security invariants should live in the platform layer (database policies, auth) instead of in the code the agent writes, so a wrong-but-compiling generation cannot silently violate them.

AI agents can build entire backends because Supabase works inside ChatGPT and Claude.
Open source video
Supabase provides a scalable, agent-first backend for modern applications.
Open source video
Row Level Security
Open source video
Empirical Resultmedium noveltymoderate evidence

Security scanning of AI-written and human-written codebases is being turned into a benchmarked capability: Deepsec deep-scans repositories with state-of-the-art models and Deepsecbench measures model performance on vulnerability detection.

Why it matters

Creates a measurable axis for choosing models in a security workflow, instead of assuming frontier coding ability implies vulnerability-detection ability.

Generalization

Any harness-level capability (scanning, verification, review) should be benchmarked separately from general coding benchmarks, because they are distinct skills.

Deepsec uncovers vulnerabilities across codebases by deep-scanning with latest models.
Open source video
Deepsecbench evaluating AI model performance on security vulnerability detection.
Open source video

Deep dives

5

Sandbox blast-radius boundaries for per-agent coding containers

Research question

Does a per-agent sandbox with the app kernel isolated from the host kernel eradicate supply chain attack impact, or only bound it — and which vectors remain (build inputs, package resolution, credentials, cross-sandbox persistence)?

Why

The security claim that 'secure by construction' replaces post-hoc testing only holds if the isolation boundary actually contains the attack surface; if not, harness design effort is being spent on the wrong control.

Moving development to sandboxes can eradicate supply chain attacks.
Open source video
Sandboxed containers isolating app kernels from host kernels.
Open source video
Relying solely on unit tests after writing insecure code is insufficient. Infrastructure must be secure by construction.
Open source video
Source video

Validating vulnerability-detection benchmarks as a distinct capability axis

Research question

Does model performance on vulnerability detection (as measured by Deepsecbench) correlate with real-world confirmed-finding yield, precision, and developer time per fix on mature codebases?

Why

If security-scanning skill does not track general coding benchmarks, security workflows need their own model-selection axis; if it does, the scanner is redundant with coding evaluation.

Deepsec uncovers vulnerabilities across codebases by deep-scanning with latest models.
Open source video
Deepsecbench evaluating AI model performance on security vulnerability detection.
Open source video
Source video

Instrumenting iteration velocity as a direction-correctness metric

Research question

Can direction-correctness be measured independently of output rate — via rework rate, reverted changes, or spec-match evaluation — and does that metric diverge from token throughput and PR landing rates?

Why

Without an instrument for direction, token-maxing pipelines optimize an actively misleading proxy and produce the wrong product efficiently.

Iteration speed is how fast you output code, but iteration velocity measures speed combined with correct direction and goal alignment.
Open source video
Moving fast without proper direction leads to building the wrong product efficiently.
Open source video
Discussion on token maxing and PR landing rates.
Open source video
Source video

Platform-layer authorization as a floor under agent-generated code

Research question

Does placing authorization invariants in the backend platform layer (Row Level Security, auth) rather than in agent-authored server code reduce the rate at which wrong-but-compiling generations silently violate access control?

Why

Generated code is the least trustworthy component in an agent-first stack, so the security floor must be inherited from the platform rather than written by the agent.

AI agents can build entire backends because Supabase works inside ChatGPT and Claude.
Open source video
Supabase provides a scalable, agent-first backend for modern applications.
Open source video
Row Level Security
Open source video
Source video

Coupling penalty of decoupled inference and harness choice

Research question

When the same harness runs across different model providers inside one cloud-agent runtime, what is the measurable cost in latency, token cost, context caching, and task success compared with a vertically integrated stack?

Why

The open per-agent computer model is only worth its added operator responsibility if harness-relative swapping costs less than the vendor lock-in it removes.

Cloudroom gives each agent its own cloud computer in an open-source ecosystem.
Open source video
Developers paying for inference should be able to use their favorite models and harnesses.
Open source video
Source video

Article ideas

4

Secure by Construction: The Sandbox Is the Security Boundary, Not the Test Suite

Post-hoc unit tests applied to already-insecure generated code cannot remove the vulnerability; assurance has to be an environmental property of the runtime, so agent harness teams should spend on isolation and construction-time guarantees instead of test volume.

Angle

Contrast the 'write then test' gate with construction-time infrastructure guarantees, and argue the harness must run entirely inside the sandbox boundary it depends on.

Source video

Iteration Velocity: Token Maxing Optimizes the Wrong Variable

Throughput metrics such as tokens generated and PRs landed are actively misleading for agentic pipelines; without a direction-correctness signal, faster pipelines just make the wrong product faster.

Angle

Reframe throughput dashboards as proxies, then argue for a velocity metric that combines landed-change rate with rework, reverts, and spec-match signals.

Source video

Where Should the Authorization Boundary Live When Agents Write the Code?

For agent-generated applications, security invariants belong in the platform layer the agent writes against — database policies and auth — not in generated application code, so a wrong-but-compiling generation cannot silently violate them.

Angle

Trace the shift of the trust boundary from hand-written server code to the data layer, and what that means for review, testing, and agent reachability.

Source video

The Coupling Penalty: What Decoupling Inference from the Harness Actually Costs

The value of per-agent cloud computers depends on an empirical question, not an ideological one: whether harness-relative model swapping costs less in latency, caching, and task success than the vendor lock-in it removes.

Angle

Treat the open-agent-platform claim as a hypothesis to be benchmarked, not a settled benefit, and enumerate where tighter coupling pays for itself.

Source video

Project ideas

4

Sandbox Escape Range

gatehouse

A per-agent sandbox that isolates the app kernel from the host kernel bounds supply chain attack impact but does not eradicate it; at least one non-kernel vector — credential access through build inputs, package resolution, or persistence across sandbox lifetimes — still escapes.

Proof of concept

Build a red-team range that runs instrumented coding agents in per-agent sandboxes and systematically attempts host-kernel reach, credential exfiltration, and cross-sandbox persistence; record every successful escape and its class.

Measurement

Number and class of successful escapes per attempt type, aggregated across N sandbox lifetimes, plus the specific vectors that remain outside the isolation boundary.

Source video

Direction-Correctness Instrument

beyond-evals

A velocity metric combining landed-change rate with a direction-correctness signal (rework rate, reverted changes, spec-match evaluation) diverges from token throughput and PR landing rates on real repositories, and predicts accepted outcomes better than those throughput proxies.

Proof of concept

Instrument an agentic delivery pipeline to log tokens, landed PRs, revert rate, rework, and a spec-match score per task; compare the composite metric against the throughput-only metrics across delivered changes.

Measurement

Divergence between composite velocity and token/PR metrics, and relative predictive power of each metric for post-hoc accepted changes.

Source video

Vuln-Bench Validity Check

beyond-evals

Model score on a vulnerability-detection benchmark correlates poorly with real-world confirmed-finding yield and precision on a mature codebase, and precision rather than recall dominates developer cost per confirmed finding.

Proof of concept

Run the scanner over a known-vulnerable corpus and a clean corpus, measuring precision, recall, false-positive ratio, and developer minutes per confirmed finding.

Measurement

Precision/recall on both corpora, false-positive ratio per thousand lines scanned, and developer minutes per confirmed finding versus benchmark rank.

Source video

Generation-Proof Auth Floor

gatehouse

Agent-generated applications built against a platform-layer authorization policy maintain access-control invariants at a higher rate than applications whose authorization lives in generated server code, particularly in the wrong-but-compiling case.

Proof of concept

Generate the same application specification N times with platform-layer policy enforcement and N times with authorization in generated server code; run an automated authorization test suite against all artifacts.

Measurement

Authorization violation rate per generated app, share of violations in apps that compile successfully, and variance across generations for each configuration.

Source video

Architectural implications

4

Development execution is relocated from the developer's host machine into per-agent sandboxed containers with the app kernel isolated from the host kernel.

Before

Code runs on a developer or CI host with host-kernel access, and supply chain compromise can reach the host.

After

Each development cycle runs in an isolated sandbox where the app kernel cannot touch the host kernel.

Consequence

Supply chain and prompt-injection blast radius is bounded by the sandbox, but the harness must be redesigned to operate entirely inside that boundary.

Source video

Agent compute, harness, and model are separated into independently selectable layers on an open platform.

Before

Cloud agents are consumed as a closed stack where the vendor controls compute, harness, and model together.

After

Each agent gets its own cloud computer and the developer chooses the model and harness on top of it.

Consequence

Evaluation and cost routing become harness-relative instead of vendor-relative, and switching costs shift from migration projects to configuration.

Source video

Authorization and data protection move into the backend platform layer (Row Level Security) that is directly reachable by the model runtime.

Before

The application server owns credentials and enforces authorization in hand-written server code.

After

The agent builds the backend against a database whose policies enforce access control, reachable from inside ChatGPT/Claude.

Consequence

Agent-generated apps inherit a security floor that does not depend on the quality of generated server code.

Source video

Security assurance shifts from post-write unit tests to construction-time infrastructure guarantees plus automated deep scanning.

Before

Insecure code is written first, then unit tests and reviews are applied as a downstream gate.

After

Secure cloud environments and automated scanners such as Deepsec are part of how the code is produced and verified.

Consequence

Verification tooling becomes part of the agent harness rather than a separate CI stage.

Source video

Tradeoffs and failure modes

5

Iteration speed versus direction

Benefit

High token throughput and PR landing rates maximize apparent progress and agent utilization.

Cost or risk

Without goal alignment the pipeline efficiently produces the wrong product, with no metric that reveals it.

Moving fast without proper direction leads to building the wrong product efficiently.
Open source video
Source video

Expanded attack surface from AI systems

Benefit

Agents write and ship large volumes of code and operate across many systems, increasing capability and throughput.

Cost or risk

The surface of attack expands with new vectors such as prompt injections and training attacks, plus latent vulnerabilities in existing human-written code.

The surface of attack for AI and traditional software has expanded massively.
Open source video
Source video

Automation versus human control

Benefit

Fleets of agents and software factories automate implementation and can operate largely autonomously.

Cost or risk

Creative control and risk management remain human domains, making human oversight the bottleneck even as execution scales.

The most critical factor in the post-AGI era is human ability to stay in control.
Open source video
Source video

Open agent platforms and paid inference

Benefit

Developers can run their favorite models and harnesses on per-agent cloud computers.

Cost or risk

Users pay for inference directly, so cost control and model selection become the operator's responsibility rather than the platform's.

Developers paying for inference should be able to use their favorite models and harnesses.
Open source video
Source video

Test-based assurance for generated code

Benefit

Unit tests are cheap to generate and give fast feedback on behavior.

Cost or risk

Tests written after insecure code do not remove the vulnerability; assurance must come from the environment and construction rather than the test suite alone.

Relying solely on unit tests after writing insecure code is insufficient. Infrastructure must be secure by construction.
Open source video
Source video

Open questions

4

Can sandboxed development actually eradicate supply chain attacks, or does it only bound their blast radius?

Why unresolved

The summary states the claim ('can eradicate') without describing the isolation mechanism's boundaries, escape risks, or what remains outside the sandbox (build inputs, package resolution, credentials).

Research direction

Red-team a per-agent sandbox harness: attempt to reach the host kernel, exfiltrate credentials, or persist across sandbox lifetimes, and record what escapes.

Source video

Does vulnerability-detection ability measured by Deepsecbench correlate with real-world fix yield on mature codebases?

Why unresolved

Only a benchmark name and one illustrative example (a specific CVE in Artifactory) are given; false positive rate, precision, and remediation cost are unaddressed.

Research direction

Run the scanner over a known-vulnerable corpus and a clean corpus, reporting precision/recall and developer time per confirmed finding.

Source video

How would iteration velocity be instrumented so it can be optimized directly instead of proxied by tokens and PR counts?

Why unresolved

The distinction is asserted conceptually ('correct direction and goal alignment') but no metric, measurement method, or threshold is provided.

Research direction

Define a velocity metric that combines landed-change rate with a direction-correctness signal (e.g., rework rate, reverted PRs, spec-match evaluation) and test whether it diverges from token/PR metrics.

Source video

What is lost by decoupling inference payment from the harness — for example, in optimization, context caching, or tool-calling fidelity?

Why unresolved

The summary advocates choosing your own models and harnesses but does not address any performance or cost penalty for the looser coupling.

Research direction

Benchmark the same harness across multiple model providers inside one cloud-agent runtime, measuring latency, cost, and task success to quantify the coupling penalty.

Source video

Key claims

8
factualVerification needed

Human-written code carries unmeasured latent vulnerabilities that constitute accumulated security debt.

Evidence

Human-written code contains unmeasurable latent vulnerabilities.

Question

What evidence supports that latent vulnerability density in human-written code is materially higher or lower than in AI-generated code?

Source video
causalVerification needed

Moving development into sandboxes can eradicate supply chain attacks.

Evidence

Moving development to sandboxes can eradicate supply chain attacks.

Question

Under what isolation model does sandboxing eliminate (rather than bound) supply chain attack impact, and what vectors remain?

Source video
causalVerification needed

The surface of attack for both AI and traditional software has expanded massively.

Evidence

The surface of attack for AI and traditional software has expanded massively.

Question

How much of the expanded surface is attributable to AI-specific vectors (prompt injection, training attacks) versus existing software growth?

Source video
opinionVerification not requested

In the post-AGI era, the most critical factor is the human ability to stay in control, with creative control and risk management remaining human domains.

Evidence

The most critical factor in the post-AGI era is human ability to stay in control.

Source video
causalVerification needed

AI agents can build entire backends because the backend platform is accessible from inside ChatGPT and Claude.

Evidence

AI agents can build entire backends because Supabase works inside ChatGPT and Claude.

Question

Does runtime reachability from inside the model's environment measurably improve agents' ability to build working backends versus tool-based access?

Source video
comparativeVerification needed

Cloudroom is the first open-source platform for running cloud agents, giving each agent its own cloud computer.

Evidence

Cloudroom gives each agent its own cloud computer in an open-source ecosystem.

Question

Is the per-agent dedicated cloud computer model economically and operationally superior to shared, pooled agent execution for typical workloads?

Source video
factualVerification needed

A tiny binary CLI coding agent in the terminal can produce extremely fast startup while running Node.js/Next.js applications and generating complex visual output.

Evidence

Fx acts as a coding agent in the terminal with extremely fast startup times.

Question

How much does agent startup latency affect task throughput and developer-perceived velocity compared with model inference latency?

Source video
causalVerification needed

Iteration speed (output rate) is distinct from iteration velocity (speed plus correct direction), and high speed without direction produces the wrong product efficiently.

Evidence

Iteration speed is how fast you output code, but iteration velocity measures speed combined with correct direction and goal alignment.

Question

Can direction-correctness be measured independently of output rate in a way that predicts product outcomes?

Source video

Connections

5