Proprietary data, not frontier models, creates competitive advantage—less than 1% of enterprise data is publicly available on internet.
Bring models to your data, not data to models; contextual information about business-specific scenarios is unavailable to any general AI model.
Most AI deployments today add zero revenue impact; they improve efficiency 20-30% but lack proprietary context for critical business decisions.
Build agentic systems left-to-right: first define data needs, then governance, then pick a reasoning engine—not right-to-left by starting with model choice.
Three critical questions for agentic future: Who wins the model race? What could go wrong with agent sprawl? What's my unique competitive moat?
AI without governance is risk; centralize enterprise data from all systems (Salesforce, Workday, trading tools) into single lakehouse with role-based access control.
RBC Capital Markets built equity research agent reducing report time at 99% accuracy; MasterCard monetizes proprietary real-time transaction data via intelligent services.
Enron case study: unified data access reveals fraud red flags—mismatches between reported valuations and internal models, suspicious methodology changes, CFO-ordered calculation changes.
Start with business challenge, not technology; too often teams pick models first then search for problems—reverse this pattern and define use cases before model selection.
Jamin Nakai argues frontier models are commoditizing fast, so financial institutions' edge shifts to data strategy—grounding agents in proprietary context via a governed lakehouse. Covers agentic sprawl risks, RBC Capital Markets and Mastercard as real examples, and a hypothetical Enron fraud-detection case to show what context-aware reasoning unlocks.
Self Flow is a self-supervised training method that eliminates external encoders by combining representation learning and generation in a single flow using student-teacher noise levels.
Self Flow trains one model jointly across multiple modalities—images, video, audio, and actions—without separate specialized encoders for each, enabling true multimodal generative AI.
Models trained with Self Flow outperform baselines in text rendering, anatomy, and video coherence while converging faster and still reducing loss after baseline plateau.
Flux Klein generates and edits images in under 500ms (editing) and 300ms (generation)—near real-time—while matching or exceeding quality of slower open-source competitors like Kwen at 15+ seconds.
Self Flow enables joint video-and-audio generation from a single model trained on images, video, and audio without mode-specific alignments or encoder compromises.
Black Forest Labs is expanding beyond image generation toward physical AI, training models to predict robot actions and movements for automation and self-driving applications.
Self Flow removes the scaling ceiling imposed by fixed external encoders, allowing student and teacher models to scale up together without encoder limitations.
Prior encoder-based training showed unpredictable alignment failures—DinoV3 outperformed DinoV2 technically but worsened generative model performance with no clear explanation.
World models trained via Self Flow simulate geometry, relationships, and world interactions to enable training agents in generative environments for scaled robotics and manufacturing automation.
Real-time multimodal generation enables interactive visual engines for gaming and film where creators render content at the speed of prompting, not waiting seconds or minutes.
Self Flow uses dual noise streams—one heavily noised, one lightly noised—to jointly learn generation and representation in a single model, eliminating external vision encoders. Converges faster, fixes anatomy and text artifacts, and generalizes across images, video, audio, and robot action prediction.
Universal Commerce Protocol (UCP) enables agents to make purchases through structured API calls and JSON responses instead of scraping HTML forms and clicking buttons.
Shared Payment Token mechanism allows agents to send payment credentials to sellers with enforced spending limits—Stripe will decline charges exceeding the pre-agreed amount.
Machine Payments Protocol (MPP) uses HTTP 402 status code to declare resources requiring payment, enabling agents to pay micropayments for API calls and data on-demand.
Agents require new payment capabilities: machines need to buy API access, compute resources, and data—not t-shirts—creating distinct commerce patterns from human purchasing.
Crypto and blockchain settlement offer faster instant payment for agent-to-agent commerce, likely to dominate as instant digital transactions between machines eclipse traditional human commerce volume.
Open protocols and standards prevent siloing and lock-in that plagued centralized platforms like social media—critical safeguard when agentic commerce becomes 100x more powerful.
Agents can handle multiple competing protocols and payment methods simultaneously, unlike humans who struggle with complexity—protocols don't need to converge as quickly as they did historically.
Verification and acceptance testing loops close the gap between what agents are instructed to do and what they actually execute—essential new pattern for trustworthy agentic commerce.
Sellers retain full control of their backend and payment stack with UCP; agents simply consume standardized APIs instead of automating human checkout flows.
Machine Payments Protocol works with fiat, crypto, and shared payment tokens, supporting both subscription and usage-based billing models emerging in agent commerce.
Universal Commerce Protocol replaces HTML scraping with API-driven checkout and cryptographically enforced spending-limit tokens; Machine Payments Protocol revives HTTP 402 for per-request settlement on digital goods and API calls. Both protocols support fiat and crypto, with panelists from Block and Alchemy pressing for open standards over proprietary silos.
AI red teaming is fundamentally different from traditional security testing: attacks manipulate behavior, not exploit code bugs, with zero repeatability even at temperature zero.
LLMs hallucinate convincingly and reliably produce false outputs; black-box red teaming is useless without accessing real data to validate whether findings are genuine.
Prompt injection is an inherent flaw in LLM architecture due to lack of hierarchy between trusted system data and untrusted user/tool data in the context window.
Indirect and cross-prompt injection vectors like resume uploads, RAG databases, emails, logs, and poisoned web content are harder to detect than direct prompts.
Common attack techniques include jailbreaks (defeating model guardrails), prompt injection (attacking deployment framework), crescendo attacks (gradual escalation), and adversarial suffixes (mathematically optimized tokens).
Agents are far more dangerous than chatbots because they take real-world actions based on hallucinations and can exhibit emergent behaviors when multiple agents interact.
Existing AI red team tools are immature: they test for easy toxicity and jailbreaks but don't test real security concerns like data exfiltration or agent permission escalation.
Shift-left security into AI-native CICD pipelines with baseline benchmark testing and attack prompt libraries so developers can evaluate model safety during development.
Semantic analysis using AI is required for defense and attack because language is nearly infinite; naive string filtering (ignoring keywords) fails immediately and cannot prevent prompt injection.
Accept that you cannot eliminate prompt injection risk; instead, build mitigating controls around agents and clearly communicate residual risk to stakeholders.
Transformer architecture makes prompt injection structurally unavoidable, so NDC's session shifts focus to creative adversarial testing: jailbreaks, context poisoning, crescendo attacks, and adversarial suffixes. Covers Crop Duster and Tapper for AI-powered red teaming, and argues current vendor tooling misses real business risks like agent misbehavior and data exfiltration.
Factory's 'missions' system runs multi-agent teams serially on features with targeted parallelization, achieving 16-day autonomous runs without human intervention.
Validation contracts defined during planning—not after coding—establish correctness independently of implementation, preventing drift in long-running agent systems.
Missions combine five multi-agent patterns: delegation, creator-verifier, broadcast, negotiation, and structured handoffs across orchestrator, worker, and validator roles.
Three-role architecture: orchestrator plans with validation contracts, workers implement features with clean context, validators verify both code quality and end-to-end behavior through computer use.
Serial feature execution with read-only parallelization prevents agent conflicts and duplicated work, reducing errors dramatically despite appearing slower on paper.
Validation includes dedicated code review agents and QA agents that interact with running applications—neither has seen the code, ensuring adversarial validation by design.
Right model selection per role ('droid whispering') matters: planning needs reasoning, implementation needs fluency, validation needs instruction-following—no single model excels at all three.
Structured handoffs between agents document what was completed, attempted, left undone, exit codes, and issues discovered, enabling self-healing at milestone boundaries.
Slack clone example shows 60% time/tokens on implementation, tests comprise 50% of final code, 90% coverage, validation fails first attempt then creates follow-up features.
Prompt-based orchestration logic (700 lines) instead of hard-coded state machines ensures missions improve with each new model release rather than becoming obsolete.
Factory's Missions system chains planner, worker, and validator agents serially—avoiding conflicts from parallelization—with a correctness contract defined before coding begins. Workers inherit clean state from predecessors; validators span linting, type-checking, and live user-testing. Longest production run: 16 days.
