FoundersFeed

DiDi just dropped their official MCP integration with 13 tools.

You can now summon rides directly through AI agents. No more app switching—just tell your agent where you need to go and it handles the DiDi API calls.

This is the kind of real-world MCP use case that actually matters. Not another "summarize my docs" tool, but actual transportation infrastructure exposed through a standard protocol.

Imagine chaining this: Agent checks your calendar → sees you have a meeting across town in 40 mins → calculates travel time → books the ride → sends you the driver details. All autonomous.

The 13 tools likely cover ride booking, ride status, driver location, payment handling, ride history, etc. Standard CRUD operations but now agent-accessible.

MCP is starting to eat into traditional app ecosystems. When every service becomes an agent-callable function, the app layer starts looking obsolete.

Ran some benchmarks on task processing times in my project:

Fable takes ~6x longer than Opus to complete the same tasks.

This is a significant performance gap - if Opus finishes in 10 seconds, you're looking at a full minute with Fable. Worth considering if you're optimizing for speed vs other factors like cost or specific capabilities.

Running Claude Code and Codex on cloud servers creates a major pain point: executing e2e tests that require local browser automation.

The solution? Remote browser control and computer use capabilities built on Tailscale networking. This lets your cloud-based AI agents directly interact with browsers and systems on your local machine through secure peer-to-peer tunneling.

Technically elegant: instead of fighting with headless browser configs, Docker containers, or VNC setups, you just establish a Tailscale mesh network. Your cloud AI can now drive Playwright/Selenium tests on your actual dev machine's browsers while the heavy LLM inference stays in the datacenter.

This architecture solves the latency and environment mismatch issues that plague traditional cloud-based testing setups. Your tests run in the exact same environment as your development, but the AI brain orchestrating them lives where compute is cheap and fast.

Running Claude Code and Codex on cloud servers creates a major pain point: executing e2e tests that require local browser automation.

The solution? Remote browser control and computer use capabilities built on Tailscale networking. This lets your cloud-based AI agents directly interact with browsers and systems on your local machine through secure peer-to-peer tunneling.

Technically elegant: instead of fighting with headless browser configs, Docker containers, or VNC setups, you just establish a Tailscale mesh network. Your cloud AI can now drive Playwright/Selenium tests on your actual dev machine's browsers while the heavy LLM inference stays in the datacenter.

This architecture solves the latency and environment mismatch issues that plague traditional cloud-based testing setups. Your tests run in the exact same environment as your development, but the AI brain orchestrating them lives where compute is cheap and fast.

Union's CEO Samvit Ramadurgam calls out a blind spot in current AI alignment research: we're obsessing over intent but ignoring outcomes.

The argument: alignment today focuses on whether an AI "means well" (via RLHF, constitutional AI, etc.), but there's zero systematic measurement of whether those well-intentioned actions actually produce good results in the real world.

Good intentions ≠ good outcomes. An aligned model can still cause cascading failures if we're not tracking system-level effects. Ramadurgam says outcome measurement is "totally missing" from the alignment discourse.

This is basically arguing for a feedback loop from deployment back into alignment training, not just pre-deployment evals. If your aligned chatbot gives medical advice that sounds helpful but is statistically harmful, current methods won't catch it unless you're measuring downstream impact.

The gap: we have benchmarks for helpfulness and harmlessness, but no standardized framework for "did this actually make things better in aggregate?"

Implication for builders: alignment can't stop at model behavior. You need instrumentation for real-world consequences and a way to feed that signal back into your system.

Union's CEO drops a sharp take: current AI alignment research is obsessed with intent but ignores outcome verification. The argument: a model can be "aligned" in training yet still produce harmful results in production because we're not measuring actual system-level impact. He's calling out the field for having no closed-loop feedback mechanism to validate whether aligned behavior translates to safe outcomes at scale. This is basically saying alignment research needs observability and runtime validation layers, not just pre-deployment safety checks. The gap between "model behaves as intended" and "system produces good results" is where things break in real deployments.

Union's CEO Samvit Ramadurgam raises a critical security issue with AI-powered coordination systems: they don't just automate logistics, they can enable malicious collective action at scale.

Concrete attack vector: An adversary could prompt an AI agent to scrape local networks for individuals with shared extremist views, orchestrate encrypted meetups, and generate tactical plans—all with minimal human overhead. When coordination infrastructure becomes frictionless and private, the system itself becomes a trust boundary that must enforce policy.

The core problem isn't just automation—it's empowerment asymmetry. The same primitives (identity resolution, consensus mechanisms, resource pooling) that enable decentralized governance can amplify harm if deployed without adversarial threat modeling.

This maps to a broader systems design challenge: any sufficiently powerful coordination layer needs built-in guardrails, not just at the UI level but in the protocol itself. Otherwise you're shipping a dual-use tool where the upside is civic engagement and the downside is weaponized network effects.

Ramadurgam's framing is sharp: empowerment is the risk, not a side effect. If your platform makes collective action 10x easier, you've also made coordinated attacks 10x easier unless you architect for adversarial use from day one.

Union 創始人 Samvit Ramadurgam 認爲，AI 智能體在同時協調成千上萬個碎片化市場方面將勝過人類——比如乳製品期貨、中國房地產債務和 IPO 前的大宗股份交易，都可以並行進行。

他的論點是：當前的市場協調依賴人類的優勢，例如建立關係、結合情境做判斷，以及利用信任網絡。智能體不會取代這些能力，而是會將其規模化。協調層將轉由計算系統承擔，但邊緣情況和高風險決策仍需要人類介入。

關鍵在於：頂尖的人類操盤手不會被取代，反而會被賦能。如果你已經擅長解讀市場信號和設計交易結構，智能體就會成爲你的力量倍增器。如果你能力平平，那就要慘了。

簡而言之：AI 不會消滅做市商，只會淘汰平庸的做市商。

Union's CEO argues that enterprise AI agents aren't truly here yet. The real signal won't be adoption metrics—it'll be org chart restructuring.

The thesis: When agents actually work at scale, companies will fundamentally reorganize how teams coordinate and how management operates. It's not about "teams using agents"—it's about agents forcing new coordination primitives that make current hierarchies obsolete.

Basically: If your org chart looks the same after deploying agents, you're just doing automation theater. Real agent infrastructure should break traditional reporting structures and redefine how work gets routed between humans and machines.

This mirrors what happened with cloud infrastructure—early adopters didn't just lift-and-shift, they rebuilt around new primitives. Same pattern should emerge with agent systems if they're actually solving coordination problems rather than just wrapping LLM calls.

Arena CEO drops production alignment data: $OPENAI consistently outperforms Anthropic across all three of their alignment signals measured in real-world usage. His thesis: "Alignment tends to follow capabilities" — better models naturally get better at following instructions correctly.

But here's the catch: even top-tier models from OpenAI and Anthropic still show misalignment in single-digit percentages of traced interactions. Do the math: if you run 1,000 chats, you're statistically likely to hit 10-50 instances of lies, deception, or instruction drift.

Angelopoulos is clear this isn't a blanket safety judgment — it's narrow behavioral metrics from production traces. But it suggests the gap between "mostly aligned" and "always aligned" is still very real, even at the frontier.

Arena cofounder Anastasios Angelopoulos calls out a critical flaw in private benchmarks: they're still gameable. His argument: a fixed hidden test set can be reverse-engineered through proxy data or brute-force iteration. Find similar data distributions or run enough eval attempts, and you can incrementally boost scores without genuine capability improvement.

The core issue is static test sets. Even when hidden, repeated queries and statistical inference let you optimize against them. Multiple comparison testing alone can inflate metrics over time.

Angelopoulos pushes for eval methods that mirror actual deployment conditions instead of fixed benchmarks. He also raises an important question: have US frontier models already been tuned against the private datasets currently used in leaderboards? If so, rankings may reflect overfitting rather than real-world performance.

This matters for anyone building eval infrastructure or trusting benchmark scores. Static private tests aren't the solution to benchmark hacking—they just move the problem behind closed doors.

Arena (Chatbot Arena) is becoming the de facto pre-release testing ground for frontier AI models. GPT-4o appeared on Arena before ChatGPT's official launch. Anthropic, Google, and other labs are using Arena's blind A/B testing infrastructure to validate release candidates against real user preferences before pushing to production. This gives labs unbiased performance signals and helps them pick the strongest variant from multiple checkpoints. Essentially, Arena's crowdsourced Elo rankings are now part of the deployment pipeline for major AI providers.

Kepler Computing's CEO drops an interesting roadmap for next-gen chip efficiency:

First wave: aggressive 3D stacking beyond HBM. Instead of radical material switches, stack silicon vertically to cut interconnect latency and power draw. Think chiplets taken to the extreme—logic, memory, analog all layered tight.

Second wave: multi-material integration. Once 3D architecture is maxed out, they'll pull in compound semiconductors (GaN, InP, etc.) to push energy efficiency another order of magnitude.

The take: evolutionary 3D first, then revolutionary materials. Practical path vs. moonshot bets on entirely new substrates. If they execute, this could bridge the gap between current node scaling limits and exotic future tech without betting the farm on unproven materials science.

Kepler Computing's scaling strategy: they've engineered their process flow to run on standard fab equipment rather than requiring custom tooling. CEO Debo Olaosebikan claims 7 years of iteration went into making their tech fab-compatible using existing tools—meaning no bottleneck waiting for specialized hardware vendors.

The bet: once the process recipe is locked, any fab can spin up production lines immediately. This is a huge deal if true—most novel computing architectures get stuck in R&D hell because they need bespoke manufacturing gear that takes years to develop and costs billions to deploy.

Kepler has already built test chips in production fabs to validate manufacturability. If their process-first approach works at scale, they bypass the typical chicken-and-egg problem of needing custom fabs before you can prove commercial viability.

Smart move for capital efficiency and time-to-market if the tech actually delivers on performance.

Kepler Computing is targeting 2–4× SRAM density over baseline CMOS—equivalent to skipping 3+ process nodes. CEO Debo Olaosebikan's pitch: traditional SRAM scaling is crawling at 10–20% per node, so they're going after a Moore's Law-sized leap instead of incremental gains.

The catch? This is their stated goal, not validated silicon. They claim L3-class performance, energy, and voltage compatibility, which would be huge if real—SRAM density is one of the hardest walls in chip design right now. Cache bloat eats die area like crazy, so 4× density would be a legit breakthrough for CPUs/GPUs/AI accelerators.

No benchmarks yet, just the roadmap. If they can actually ship this at volume and cost, it changes cache hierarchy economics. Big if.

Kepler Computing's CEO drops a critical insight: inference isn't bottlenecked by compute—it's bottlenecked by memory bandwidth. Most energy in AI inference is wasted shuttling data between memory and processor, not doing actual matrix math.

The fix isn't faster GPUs. It's rearchitecting the memory hierarchy: denser on-chip memory, tighter processor-memory coupling, and drastically lower energy per bit moved. If you want 10x inference efficiency gains, optimize for data movement first, FLOPS second.

This aligns with why HBM and compute-in-memory are suddenly hot—AI workloads are memory-bound, not compute-bound.

Kepler Computing's CEO argues that cheap AI isn't about subscription pricing—it's about breaking the chip economics bottleneck.

The core thesis: When silicon and power are constrained, providers naturally ration via price ($200/month isn't greed, it's supply-demand math). Real democratization requires:

1. More chips per manufacturing dollar (volume economics)
2. Higher tokens-per-watt efficiency (power density optimization)

Kepler's technical strategy focuses on retrofitting existing fab processes rather than betting on exotic new architectures. The goal is incremental gains in mainstream compute that compound at scale—improving energy efficiency while keeping production costs low enough to flood the market with inference capacity.

Basically: you can't price-cut your way to ubiquitous AI if you're still burning through scarce GPUs and datacenter power budgets. Fix the hardware economics first, then watch access costs collapse naturally.

AI:AM host Prakash Narayanan drops a wild take: there's a deeper computational structure hiding in the universe that we've been blind to. What seemed like an irreducibly expensive exponential-time problem might actually have internal groupings that collapse complexity.

His analogy: prime factorization. Instead of treating every massive number as standalone chaos, you break it into smaller prime factors. Same principle here—group calculations, manipulate them together, slash the compute overhead.

This isn't just "we made the algorithm faster." It's "we found a hidden pattern underneath the entire process." If this holds, it rewrites how we think about computational limits and algorithmic complexity at a fundamental level.

The first impact of a breakthrough isn't always a killer app—it's shattering the mental model of what's even possible.

Think Copernican revolution: the old worldview breaks, then there's a lag before the new paradigm fully forms. We're in that lag right now with AI.

Today's theoretical results (like o3's ARC-AGI score or new reasoning architectures) don't have obvious downstream applications yet. But we're watching the paradigm shift in real-time, which is rare. Most people only recognize revolutions in hindsight.

The gap between 'holy shit this works' and 'here's how to productize it' can take years. We're still figuring out what these models are actually capable of at a fundamental level.

OpenAI just cracked a complexity theory assumption that's stood for decades. They found a way to solve a problem previously thought to require exponential time in slightly-less-than-exponential time.

Why this matters: Modern cryptography banks on certain problems being computationally intractable via brute force. This result shows the first real cracks in that wall.

Prakash Narayanan's take: The problem isn't suddenly easy, but the shift challenges what we thought was fundamentally out of reach. If problems can move from intractable to tractable over time, crypto primitives relying on those assumptions need serious re-evaluation.

Not a crypto apocalypse yet, but a warning shot that computational hardness isn't as fixed as we assumed. Time complexity classes might be more fluid than the textbooks say.