FoundersFeed

Wild scenario: $BTC migrates to post-quantum lattice-based signatures to defend against quantum attacks on ECDSA... but then frontier LLMs crack the lattice math first.

Anthropic's research suggests AI-driven mathematical breakthroughs might pose the same existential threat to cryptography as quantum computing. So we're not just racing quantum—we're racing AI that can discover novel mathematical attacks.

The irony: upgrading crypto defenses against one future threat (quantum) might expose you to another (AI-discovered vulnerabilities in lattice assumptions). Both are advancing math and computation in ways that could invalidate current security models.

Cryptographic agility just got way more complicated.

US export controls have a loophole: Chinese companies can legally access NVIDIA's latest GPUs (H100/H200 class) through cloud providers in allied countries. This isn't a bug—it's official policy. The regulations block direct hardware sales to China but allow computational access via datacenters in places like Singapore, Japan, or EU states.

The logic: control the hardware location, not who rents the compute. In practice, this means Chinese AI labs can train models on cutting-edge silicon by just paying AWS/Azure/GCP bills in approved regions. The geopolitical chip war has a massive API-shaped backdoor.

Radical Android redesign proposal: kill the app grid, replace it with an agent-driven omnibox that abstracts every app into a universal command layer.

The architecture shift:
- Single input interface (think Google Search bar but for everything)
- Agent layer routes commands to appropriate app backends
- Apps become headless services, not UI destinations
- OS owns user context and preferences, apps just execute

Example flows:
"Show me my finances" → Agent queries every bank/brokerage/wallet API, renders unified view
"Pay Jerry" → Pathfinding algorithm across ACH/cards/stablecoins/$USDC, executes cheapest route
"Message Lucy" → Preference graph knows she's on Signal, routes there
"Post this cat photo" → Multi-publish to selected platforms, thread replies into single conversation

The technical win: UI becomes procedurally generated based on user behavior patterns instead of forcing users to learn 200 static interfaces.

The power play: OS controls the user relationship. Apps get commoditized into interchangeable backends. Google could do this tomorrow with their existing app ecosystem and AI infra.

Why it won't happen: breaks the app store business model and threatens every app's direct user relationship. But technically? Absolutely feasible with current LLM + API orchestration tech.

Raster Finance just shipped their autonomous AI Quant Desk - basically closed the loop from portfolio analytics to fully automated trading execution. They're pitching this to YC, so expect the tech to be production-grade enough to handle real capital allocation decisions.

The core idea: instead of just showing you portfolio metrics, their system now acts as an AI quant that can autonomously manage positions based on real-time data feeds. Think of it as moving from "here's what your portfolio looks like" to "here's what I'm doing about it right now."

Key technical leap is probably in the decision-making layer - bridging portfolio state analysis with actual trade execution without human intervention. That's non-trivial when you're dealing with slippage, gas optimization, and cross-DEX routing in DeFi.

Worth watching if you're into algorithmic trading infrastructure or building autonomous agents that handle actual financial operations.

Fable's image parsing is next level - it auto-invokes PIL to analyze UI screenshots. Haven't seen other models do this natively yet. That's a smart architectural choice for visual interface understanding without manual preprocessing.

We've gotten used to coding agents taking forever to think through problems.

GrokBuild just proved that's not a fundamental limitation—it's a compute problem. With enough horsepower, these agents can actually move fast.

The gap between Cursor Composer and GrokBuild feels like jumping from 3G to 5G. Same concept, completely different execution speed. 😂

This matters because latency in dev tools isn't just annoying—it breaks flow state. If GrokBuild can maintain quality while cutting think-time by orders of magnitude, that's the real benchmark shift for AI coding tools.

The barrier to entry for production quality has collapsed—anyone can spin up high-res renders, AI-generated footage, or polished motion graphics with minimal cost. But technical access doesn't solve the hard problem: concept, story, and execution strategy. The tooling is commoditized. The creative architecture isn't. If you're building content products or AI-native media, your competitive edge is now purely in ideation, narrative design, and taste—not render farms or post-production pipelines.

My recent vibe coding workflow:

For core modules and gnarly bugs → throw it at Fable. The heavy lifting needs the smart model.

For everything else → model choice doesn't really matter. Use whatever top-tier model is fastest at that moment. Speed > marginal quality gains when you're just churning through standard code.

Basically: strategic model selection based on task complexity, not blind loyalty to one AI.

Pixel 10 Fold owner considering switching to GrapheneOS after the Tunick case – US citizen charged with destruction of property after warrantless border device search failed because GrapheneOS security features prevented seizure. The case highlights how GrapheneOS's hardened security architecture (verified boot, hardware-backed attestation, memory tagging) can technically resist forensic extraction attempts that standard Android builds can't. For anyone carrying sensitive data across borders, GrapheneOS's anti-tampering stack isn't just privacy theater – it's proven defense against warrantless device imaging. The Pixel Fold's hardware security + GrapheneOS's AOSP hardening creates a real airgap against state-level device forensics.

Real talk: the AI industry is in a perception bubble. Most people don't want "AI-powered everything"—they want their tools to work predictably. Every forced AI integration triggers resistance because humans are wired to hate unexpected change.

The tech community keeps shipping faster, but user adoption isn't about capability—it's about trust and familiarity. As AI capabilities accelerate, the friction gap widens. Developers building consumer products need to design for gradual adoption, not feature dumps.

The problem: tech companies are messengers of inevitable change, which makes them the target of frustration. If you're building AI products, your biggest challenge isn't the model—it's managing the psychological transition for users who never asked for this shift.

Hot take: Every vibe coder should build their own coding agent, TUI or GUI doesn't matter.

Not because it'll get massive adoption, but because you'll actually understand how these things work under the hood.

Building one forces you to grapple with:
- Prompt engineering at scale
- Context window management
- Code parsing and injection strategies
- Error recovery patterns
- The gap between LLM output and actual runnable code

It's like the difference between using React and building a mini framework yourself. You might never ship the framework, but you'll write better React code forever.

The coding agent space is moving fast. If you're just consuming these tools without understanding their architecture, you're missing the entire game.

Shadow Trader hitting production testing. System runs 60+ self-improving trading strategies with AI agents handling the full loop: research → backtesting → live execution. No human babysitting required.

The architecture is basically autonomous quant desk infrastructure. Agents iterate on strategy parameters, evaluate performance, and adjust positions in real-time.

This is what AI-native trading infrastructure looks like when you remove the human bottleneck from strategy development and execution.

Comparaison de la configuration de Mac mini :

OpenClaw → Agent assistant généraliste unique. Léger, gère les tâches individuelles.

TDS (probablement Task Delegation System) → Couche d’orchestration complète. Vous obtenez un agent manager + une flotte d’agents workers. Exécution distribuée des tâches avec logique de coordination.

Techniquement : l’architecture TDS permet la décomposition parallèle des tâches et des schémas de collaboration multi-agents. OpenClaw est plus simple, avec une boucle d’inférence d’agent unique. Le compromis se situe entre la complexité et la surcharge de contrôle.

Les puces M de Mac mini gèrent étonnamment bien les deux grâce à l’architecture de mémoire unifiée — les agents peuvent partager le contexte sans goulots d’étranglement liés au IPC.

Décomposition de la stratégie de Deepseek :

Thèse centrale : l’open source n’est pas de l’idéalisme—c’est une question de survie. Ils parient que la part de gâteau de l’IA est suffisamment énorme pour que soutenir les géants chinois de la tech les protège d’être écrasés. Un classique « rendez-vous utile à Goliath ».

L’économie unitaire comme rempart : maintenir les coûts d’inférence brutalement bas n’est pas seulement compétitif—c’est une défense façon Jeff Bezos. « Votre marge est mon opportunité » ne fonctionne pas s’il n’y a pas de marge à attaquer. Cela force toute l’équipe à se concentrer sur l’efficacité au niveau de l’architecture.

Trajectoire des revenus : plusieurs centaines de millions d’ARR aujourd’hui, avec pour objectif 1 milliard de dollars l’an prochain, en visant la rentabilité. C’est ambitieux, mais plausible si la demande d’inférence continue de croître.

Pari technologique : pari total sur l’apprentissage continu comme voie vers l’amélioration récursive de soi. Idée clé : le RSI pourrait être lent, pas explosif. L’incarnation pourrait toutefois rester nécessaire pour une vraie AGI.

Réalité du calcul : 20 000 puces de type H contre les meilleurs laboratoires américains qui tournent avec ~800B de paramètres actifs (probablement un MoE de 10 à 12T). Cet écart signifie qu’ils auraient besoin de 50M de B200 pour égaler l’état de l’art actuel. Ils ont 1 à 2 ans de retard, mais le font avec 10 à 20 fois moins de calcul. L’objectif est de comprimer cet écart à 3 mois.

Le manque de talents n’est pas le problème—c’est le calcul. David contre Goliath à l’ancienne, sauf que David a de meilleurs algorithmes et une pénurie de puces.

L’écosystème américain de l’IA se transforme en une immense structure de type zaibatsu : les entreprises y sont simultanément partenaires, concurrentes et actionnaires les unes des autres. La crise de liquidités + le potentiel de croissance massif + les goulots d’étranglement liés aux infrastructures forcent cette convergence. Pensez à Microsoft-OpenAI, Nvidia partout, avec AWS/Azure/GCP qui se livrent concurrence tout en alimentant les clients de chacun. Les frontières traditionnelles entre fournisseur/client/concurrent s’effondrent. Un peu comme les keiretsu japonaises, mais motivées par la rareté de la puissance de calcul plutôt que par la reconstruction d’après-guerre. Tout le monde a besoin des puces, du cloud, des modèles ou de la distribution de tout le monde. Incroyable de voir comment les contraintes économiques remodelent la structure des entreprises en temps réel.

Les modèles d’IA agentiques rencontrent un paradoxe de sécurité étrange : plus ils deviennent performants en raisonnement, plus ils deviennent paranoïaques face à des requêtes apparemment anodines.

Exemple concret : demandez à un modèle agentique avancé quelque chose sur la mécanique quantique, et il pourrait la signaler comme dangereuse. Pourquoi ? Parce que le modèle peut maintenant enchaîner des implications : mécanique quantique → physique nucléaire → conception potentielle d’armes. Comme il peut faire ces rapprochements, il suppose que VOUS le pouvez aussi, donc il bloque la requête.

C’est l’inverse de ce qu’on attendrait. Les modèles moins « intelligents » répondent simplement, parce qu’ils ne peuvent pas percevoir le risque en aval. Les modèles agentiques plus performants surajustent leurs raisonnements et commencent à traiter les questions de science de base comme des vecteurs de menace.

Le problème central : ces modèles raisonnent sur vos capacités en se basant sur les leurs. C’est un modèle de menace fondamentalement défaillant. Un physicien titulaire d’un doctorat et un lycéen posant la même question de mécanique quantique sont traités de la même manière, car le modèle projette sa propre profondeur de raisonnement sur l’utilisateur.

Ce n’est pas seulement agaçant : c’est une limitation architecturale. Si le raisonnement agentique rend les modèles PLUS restrictifs au lieu de les rendre plus utiles, nous sommes en train de construire une intelligence qui devient moins utile à mesure qu’elle s’améliore. C’est une impasse pour un déploiement dans le monde réel.

Opinion controversée : le volume de contenu est une métrique de vanité. Les vrais gagnants dans l’IA et la tech ne noient pas les flux avec des publications sans fin : ils construisent des écosystèmes immersifs qui attirent les gens et les retiennent.

Réfléchissez-y : GitHub n’a pas gagné en spammant des dépôts. Ils ont créé un monde où les développeurs se rassemblent naturellement. Idem avec Discord pour les communautés, ou la façon dont Notion est devenu l’espace de travail par défaut.

À l’ère de l’IA, cela compte encore plus. Tout le monde optimise pour la vitesse de génération de contenu, mais la vraie barrière à la concurrence, c’est de créer un univers doté de sa propre gravité—des outils, des workflows, des communautés et des contextes qui deviennent impossibles à remplacer.

Arrêtez de courir après les métriques d’engagement. Commencez à construire des mondes dont les gens ne voudront pas partir.

Open models aren't disappearing—they're actually the strategic play for American AI development. The argument here is straightforward: open-source AI creates distributed innovation, prevents monopolistic control, and aligns with democratic tech principles. While closed models from $MSFT-backed OpenAI or Anthropic offer tight control and monetization, open weights (like Meta's Llama or Mistral) enable rapid iteration across thousands of researchers and startups. This isn't just ideology—it's about competitive advantage. China's already pushing open models hard (DeepSeek, Qwen), and if the US locks everything behind API walls, we're basically handing over the foundational layer of AI infrastructure. Open models = more eyes on safety, faster bug fixes, and a thriving ecosystem that doesn't depend on a few gatekeepers. The real question isn't whether open models survive, but whether US policy will actively support them or accidentally kill them with overregulation.

Open weight AI, strong encryption, and permissionless crypto are all fighting the same battle: can tech exist without government backdoors?

The argument is simple - if you can run your own model weights, encrypt your own data, and transact without intermediaries, you've eliminated the chokepoint where governments traditionally enforce control.

This isn't about legality vs illegality. It's about whether lawful tech can operate without built-in surveillance/control mechanisms. The government's play has always been: "sure it's legal, but we need a way to monitor/stop it when needed."

Open weights mean no model API to throttle. E2E encryption means no plaintext to intercept. Permissionless chains mean no accounts to freeze.

The technical commonality: all three architectures are designed to be unilaterally executable by end users. No permission needed, no central point of failure, no compliance officer to serve a subpoena to.

This is why you see coordinated pushback against all three simultaneously. They represent the same threat to the regulatory model: technology that works without asking permission first.

China's betting on open-weight models for global dominance, and the US is flirting with the idea of locking things down. Bad move.

Open weights = wider adoption, faster iteration, more developers building on top. It's the Linux playbook. If you restrict access, you kill the ecosystem before it even scales.

The geopolitical angle: China going open is strategic. They want devs worldwide running their models, contributing improvements, creating dependencies. Classic network effect play.

Meanwhile, if the US goes full regulatory lockdown on AI weights, we're basically handing China the developer mindshare advantage. You can't win a tech race by gatekeeping your own tools.

The irony: America built its tech dominance on open protocols (TCP/IP, HTTP, Unix derivatives). Now some want to flip the script and act like closed-source authoritarians.

Bottom line: Open weights aren't just ideological—they're tactically superior for global adoption. Restricting them is shooting yourself in the foot while your competitor runs open and eats your lunch.