标签：#ai

Nilekani remains Fundamentum's anchor investor as the firm expands its leadership team and targets AI and fintech startups in India.

SpaceXAI has rolled out Grok 4.5, the first model it trained with Cursor.

Because of the way they are trained, large language models capture only a slice of human language. They’re trained on the written word, from textbooks to social media posts, and our speech as captured in movies and on television. These models have minimal access to the unscripted conversations we have face to face or voice to voice. This is the vast majority of speech, and a vital component of human culture. There’s a risk to this. The increased use of large language models means we humans will encounter much more AI-generated text. We humans, in turn, will begin to adopt the linguistic patterns and behaviors of these models. This will affect not just how we communicate with one another, but also how we ...

OpenAI found two unrelated bugs masquerading as one in ChatGPT's data infrastructure. Silent hardware corruption on one Azure host and an 18-year-old race condition in GNU libunwind's setcontext function with a one-instruction vulnerability window. The breakthrough came from switching to population-level crash analysis rather than examining individual core dumps. By Steef-Jan Wiggers

When an AI API call fails, the tempting reaction is to switch models or providers. That is often premature. A large share of 401, 429, model_not_found, timeout, and confusing billing issues are not model-quality problems. They are route-evidence problems. The request moved through a key, base URL, model ID, retry rule, fallback path, and billing record. If those pieces are not visible, changing the model can hide the real cause. Before you replace the model, debug the route. A practical route checklist Confirm the key scope. Is the API key attached to the right project, environment, and quota rule? A key that works in one workspace can fail in another because the limit, budget, or allowed model set is different. Confirm the base URL. Many OpenAI-compatible errors start with a request going to the wrong host, version path, or proxy. Check the exact Base URL used by the client, not the one written in a README from memory. Confirm the model ID. A model_not_found error is not always a provider outage. It can be a copied alias, a retired ID, a route that does not support that model, or a mismatch between public model names and API model IDs. Separate 401, 403, 404, and 429. These errors ask different questions: 401: is the key present and valid? 403: is the key allowed to use this route or model? 404/model_not_found: is the exact model ID available on this route? 429: is the limit coming from the user, key, project, provider, retry loop, or budget rule? Treating all of them as provider instability wastes time. Look for retry and fallback behavior. A single user action may trigger more than one model call. Agents, RAG pipelines, streaming clients, and SDK retries can quietly multiply traffic. If fallback is enabled, the served route may differ from the requested model. Check the usage and charge record. A successful response is not the end of the test. You should be able to explain which key made the call, which model was requested, which route served it, how many tokens

This post contains Railway referral links. If you sign up through one I get a bit of credit. I build Old Light , a real-time strategy game that runs in the browser. Claim stars, grow an economy, send fleets, all while other players and NPC empires do the same. The second a build finishes or a fleet lands, the server pushes it to every connected client over a WebSocket. That last part, a long-lived server holding an open socket, rules out most of the usual hosts. Here's what it ruled in. Why not Vercel or Netlify Serverless shines when your backend is stateless functions. It's the wrong shape the moment you need a socket that stays open: socket.io wants one process that lives for the whole session, and serverless boots per request and then freezes. You can bolt on a managed WebSocket service, but that's a second system to run and pay for. Railway runs your service as a normal long-lived process, so socket.io just connects. Fly.io does this too with more knobs to turn. I wanted to ship, so Railway won. Monorepo, two services Old Light is an npm workspaces monorepo: a shared types package, an Express plus TypeORM plus socket.io API, and a Vite web app served by a small Express server. On Railway that's two services on the same repo, each with its own root directory and build command, shared built first. They deploy as separate origins, so the web app reads the API's URL from VITE_API_URL . Vite bakes that in at build time, so it's a build variable, not a runtime one. Postgres is a plugin that injects DATABASE_URL , and production runs migrations rather than synchronize . WebSockets need nothing special until you run more than one instance, at which point you'd add a Redis socket.io adapter. I haven't left a single box yet. A healthcheck that stops version skew Two services don't go live at the same instant. Push a commit that touches both, the web finishes first, and for a minute your new frontend is calling API routes that don't exist yet. It 404s, then heals itself o

AI founders love the glamorous agent stories: coding agents, sales agents, AI doctors, AI lawyers. But if you dig through the YC 2026 batch data, one of the more interesting signals is decidedly unglamorous: insurance . Out of 477 real-ish company records in the current snapshot, 25 match insurance-related keywords — about 5.2% — and 8 companies sit in the Fintech → Insurance subindustry. Not a tidal wave. But it's enough to suggest something worth paying attention to: insurance is quietly becoming one of the better wedges for AI agents that actually ship. The reason is simple. Insurance is wall-to-wall documents, rules, judgment calls, exceptions, approvals, claims, underwriting, and cross-system coordination. In other words: wall-to-wall work that agents can do and humans hate doing. Insurance is not fintech's leftover category Most people file insurance under "slow fintech": aging distribution, legacy systems, long processes, heavy regulation. From an AI builder's perspective, that list of flaws reads more like a list of opportunities. Insurance workflows are highly structured — but not fully structured. Policies, claims files, medical records, photos, repair estimates, payout history, compliance clauses: the inputs are messy and heterogeneous. Yet every step has a crisp objective: is this covered, what documents are missing, how should this risk be priced, can this pass approval. That's not a chatbot problem. It's an agent problem — reading documents, following procedures, calling systems, leaving audit trails, handling exceptions. And precisely because it's complex, insurance is more likely to command real budget than yet another AI writing tool. Agents die without boundaries; insurance comes with them built in The most common failure mode for early agent products: they sound like they can do everything and end up doing nothing well. Insurance workflows hand you boundaries for free: Inventory and asset processes can be automated end to end Medical prior authori

If you could pick only one counterintuitive number from the YC 2026 batches, make it this one: out of 477 real-ish company records, 366 list San Francisco as their location — roughly 77%. For comparison: New York City has 24. London 10. Boston 7. Los Angeles 4. Fully remote? 3 companies. Even if you add the 11 tagged "San Francisco + Remote", the conclusion doesn't budge: AI startups aren't spreading across the map. They're re-concentrating in one city. This isn't Bay Area nostalgia. It's industry structure casting a vote. Remote won work. It didn't win startup density. One of the most popular takes of the past few years: software teams can start anywhere, so companies no longer need the Bay Area. That take wasn't entirely wrong — tooling, cloud services, open models, and online fundraising genuinely lowered the barrier to starting a company. But the YC 2026 location data is a reminder that a lower barrier is not the same as a vanished advantage. Building an AI startup isn't just writing code. It runs on model gossip, talent flow, customer pilots, investor feedback, peer pressure, and extremely fast narrative iteration. Much of that works online. But the densest informal information still travels fastest offline. San Francisco's edge was never the office space — it's collision frequency. AI made same-city learning matter again In the classic SaaS era, most domain knowledge came from customers and product cycles were relatively stable. You could build a vertical software company in any city and grind toward PMF at your own pace. The AI era doesn't work like that. Model capabilities turn over every few months. Agent architectures keep getting rewritten. Inference costs, context windows, voice, tool calling, and eval infrastructure are all on rolling release. A seemingly minor technical shift can redraw your product's boundaries overnight. In that environment, whoever hears real feedback earlier, learns earlier what others tripped over, and understands earlier what inv

For a long time, education and work rewarded one thing above all else: the ability to produce correct answers. School exams were built around it. Technical interviews were built around it. Even many engineering jobs were built around it. The person who could respond faster, explain better, and deliver the right output was often seen as the most valuable person in the room. But AI is changing that. Today, answers are becoming cheap. With modern AI tools, anyone can generate code, summaries, documentation, architecture drafts, and even product ideas in seconds. The scarcity is no longer in producing answers. The scarcity is in defining the right problem. That is why, in the AI era, learning how to ask better questions matters more than learning how to write better answers. The Bottleneck Has Moved The biggest shift is not that AI can answer questions. The bigger shift is that answering is no longer the hardest part. When answers can be generated instantly, the real bottleneck becomes: What exactly should be asked? What is the real problem behind the surface request? What constraints actually matter? What outcome is considered good enough? AI can generate many possible answers. But it still depends heavily on the quality of the question. A vague prompt creates vague output. A precise question creates leverage. In that sense, the person who defines the problem is now more important than the person who simply responds to it. The Problem Setter Is More Valuable Than the Problem Solver This idea may sound exaggerated at first, but it becomes obvious in practice. Suppose someone says: Optimize this system. That sounds like a reasonable task, but it is actually too weak to produce a strong result. Optimize for what? Cost? Latency? Reliability? Simplicity? Team productivity? Now compare it with this: We have a Node.js API running on AWS ECS. Under burst traffic, CPU throttling causes latency spikes. How can we reduce p95 latency without increasing infrastructure cost by more

We just opened the waitlist for Something, and the part that surprised me most while building it wasn't the multi-agent orchestration — it was how hard it is to make an AI actually disagree. Every model we tested defaults to being helpful, which in practice means agreeable. Even when explicitly prompted to "find flaws," the outputs would soften into "here are some considerations" instead of a real critique. We had to engineer around this specifically: Separate system prompts with opposing reward framing — one agent optimizes for identifying growth potential, the other is explicitly told its only success metric is surfacing a disqualifying flaw Structured output forcing a verdict, not a summary — the skeptic agent (Nothing) has to commit to a specific weakness category (unit economics, timing, technical feasibility) rather than hedging across all of them A reconciliation step where both outputs get merged into one conviction score, so the founder isn't just reading two contradictory paragraphs If anyone's built adversarial agent setups and hit the same "it just wants to agree with me" problem, curious how you solved it. [Everyone who has a brain is a founder here] something-waitlist.vercel.app

Google shipped AlloyDB AI functions GA with a proxy model architecture that trains a lightweight local model from LLM outputs, then runs queries at database speed without external calls. Smart batching delivers 2,400x throughput improvement. The proxy model reaches 100,000 rows per second in preview, but benchmark numbers apply only to ai.if in internal testing. By Steef-Jan Wiggers

The Kubernetes community has introduced a framework for integrating AI into open-source maintainership, emphasising human accountability in code quality and oversight. AI tools may streamline workflows, but ultimate responsibility lies with human maintainers. The framework requires disclosure of AI usage in contributions and prohibits AI-generated commit messages. By Olimpiu Pop

We have all been there: you open your editor to write a simple feature, and within ten minutes, your screen is a chaotic mess. You are drowning in squiggly red lines, bright rainbow bracket lines, a crowded sidebar, Git blame popups blocking your text, and terminal notifications screaming for attention. Modern IDEs like VS Code and Cursor are incredibly powerful, but out of the box, they are built to distract you. If you want to achieve true flow state, you need to strip away the noise. Here are 10 minimalist extensions built for both VS Code and Cursor that are explicitly engineered to eliminate clutter, reduce cognitive load, and help you focus on the only thing that matters: the code. Interface and Zen Mode Cleansers 1. Zen Mode (Built-in, but needs tweaking) The Vibe: Complete visual isolation. What it does: While not an external extension, true minimalism starts here. Hitting Cmd+K Z (or Ctrl+K Z) instantly hides the activity bar, status bar, sidebar, and editor tabs, leaving you with nothing but your code centered on the screen. The Focus Trick: Go into your settings and toggle zenMode.hideLineNumbers to true to get rid of the left-hand numbering margin entirely for deep reading sessions. 2. APC Customize UI++ The Vibe: Pixel-perfect control over editor bloat. What it does: If you love the layout of hyper-minimalist editors like Zed but want to keep the power of Cursor or VS Code, this is your holy grail. It allows you to shrink font sizes of the UI independently from your code, hide specific layout borders, trim the massive top title bars, and customize panel padding to give your code room to breathe. 3. Customize UI / Active Bar Hidden The Vibe: Moving target elements out of sight. What it does: The left-hand Activity Bar (with the extensions, search, and source control icons) is a constant source of colorful badge notifications. Use this to hide it entirely. You can easily trigger those panels via keyboard shortcuts (Cmd+Shift+E for explorer, Cmd+Shift+F fo

There's a comfortable thing people say when they see an AI agent query a code map. "Nice crutch. For now." The logic underneath it is reasonable. Coding agents are young. Context windows are small and getting bigger. Models are dumb today and will be smart tomorrow. So a structural index, the thing that hands the agent a dependency graph it would otherwise have to reconstruct, looks like a patch over a temporary weakness. Wait two releases. The model will just hold the whole repo in its head and the map becomes a quaint workaround, like a spellchecker for someone who learned to spell. I build one of those maps Sense . I went looking for the data that would kill it. I didn't find it. I found the opposite. What a map hands an agent is a computed fact. What a better model hands you is a more confident guess . No amount of model progress turns the second into the first, because the difference between them isn't a quality gap that closes with scale. It's a difference of kind. The rest of this piece is the two findings that forced me there. The belief, stated fairly The claim at full strength, because a weak version is easy to knock over. A code map exists to compensate for what the model can't do yet. Today's agent greps, samples, and guesses at structure because it can't read the whole codebase at once. Tomorrow's agent reads all of it, reasons over all of it, and the guessing stops. Bigger windows plus better weights equal no more blind spots. The map is scaffolding you'll tear down once the building stands. If that's true, the right move is to skip the tool and wait. Both findings, in order. Proof one: the best model available was still blind The benchmark ran the same task on thirteen real Ruby repos. Pick the hub model of an app, the Inbox , the MergeRequest , the Spree::Order , and ask the agent to find every place that depends on it before a teardown change. The non-obvious dependents, the ones scattered through concerns and workers and config-string registries, w

Anthropic Shipped @claude for Slack. My Team Runs on Telegram. Anthropic just shipped @Claude inside Slack channels. Tag the bot, it reads the thread, does work async, posts back. Nice product. Except roughly 95% of small businesses don't live in Slack — they run on WhatsApp, Telegram, and Gmail. If you're a solopreneur or a 1-to-10-person team, here's the exact four-part recipe I use to run the same pattern in Telegram for under $12/month. What Anthropic actually shipped (and who it's for) Anthropic shipped an enterprise distribution deal wearing a product launch t-shirt. @Claude for Slack lets you tag the bot in a channel or thread, gives it channel memory, connects to your other apps, and returns work asynchronously — but only on Slack Team and Enterprise plans. That's the punchline: it lives where the annual contracts live. Look at the raw user counts. Slack's own reporting puts it around 35–40 million weekly active users globally. WhatsApp is over 2 billion. Telegram is over 900 million. Gmail sits around 1.8 billion. In the 1-to-10-employee segment outside US tech, Slack penetration is single digits. Small teams in Europe, LATAM, and most of Asia coordinate in WhatsApp groups and run pipeline out of Gmail. They are not about to add Slack seats at $15/user/month just to get an @Claude mention. That's a rational call for Anthropic — Slack is where the enterprise procurement motion already exists. It's just not a product for the operator segment. And the pattern they productized is trivially replicable on any messenger with a bot API. Platform Weekly/monthly active users Bot API Cost to run a mention-bot Slack ~35–40M WAU Yes, paid plan $15/user/mo + API Telegram ~900M MAU Yes, free ~$5–12/mo API only WhatsApp Business ~2B MAU Yes, metered $0.005–0.08/conversation + API Gmail ~1.8B MAU Pub/Sub push Free tier + API The four-part recipe (works in any messenger) Every mention-bot is the same four moving parts: a webhook that fires on mention, a context store that ho

From answering questions to solving problems — Phase 6 of the Jarvis AI Platform After Phase 5, Jarvis could hear, speak, remember conversations, retrieve documents, and use tools. But every interaction was still limited to a single request and a single response. You: "What's the weather in Kathmandu?" Whisper ↓ AiOrchestrator ↓ WeatherTool ↓ Text-to-Speech Jarvis: "It is 22°C and clear." That works well for simple questions. It completely breaks down when a task requires multiple decisions. The Limitation of Single-Turn AI Imagine asking: Research the top 3 Java AI frameworks, compare them, and summarize the findings. A traditional chatbot usually replies: I don't have enough information to research that. The problem isn't intelligence. The problem is planning. To answer properly, the AI must: Search for Java AI frameworks Search for comparisons Gather information Analyze results Produce a summary That requires multiple tool calls and reasoning between each one. This is exactly what AI agents are designed to do. What Is the ReACT Pattern? ReACT stands for: Reason + Act Instead of generating one response, the AI repeatedly performs a reasoning loop. THINK ↓ ACT ↓ OBSERVE ↓ THINK ↓ ACT ↓ OBSERVE ↓ FINAL ANSWER Example: THOUGHT: I should search for Java AI frameworks. ACTION: search INPUT: Java AI frameworks 2026 ↓ OBSERVATION: Spring AI LangChain4j Semantic Kernel ↓ THOUGHT: Now I need comparison data. ↓ ACTION: search INPUT: Spring AI vs LangChain4j ↓ FINAL ANSWER Instead of guessing everything up front, the AI gathers information step by step before producing the final response. The Biggest Architectural Decision The most important design decision of Phase 6 was not modifying the existing chat pipeline . Instead of turning AiOrchestrator into a giant class responsible for both chat and agents, agents became a completely separate orchestration layer. ❌ Wrong AiOrchestrator ↓ Single Chat ↓ Agent Logic ↓ Tool Logic ↓ Everything Mixed Together ✅ Correct AgentController

In January, three researchers built a shopping agent on Google's Agent Payments Protocol (AP2), the standard designed to make agent-led purchases safe through cryptographically verifiable mandates. Then they attacked it with nothing more exotic than adversarial text. The paper, "Whispers of Wealth" ( arXiv 2601.22569 , revised May 2026), reports that simple prompt injections reliably subverted the agent: one attack steered which products the agent ranked and bought, another exfiltrated sensitive user data. The part of the stack that failed was not the cryptography. The mandates verified exactly what they were designed to verify. What folded was the layer that exercises judgment. Hold that result in mind, because the agent economy is currently pouring money into judgment. Everyone is hiring a referee Look at what shipped in the last few months for agent-to-agent commerce, and a single pattern repeats: put the money in escrow, and let a judge decide when it comes out. ERC-8183 formalizes it: funds sit in an escrow contract while an Evaluator - an agent or a human - decides whether the deliverable meets the spec before releasing payment. It is the pattern Virtuals' Agent Commerce Protocol runs on. Circle has piloted an escrow agent for USDC flows. Kustodia and Nava (which raised $8.3M) are startups built on the same shape. And on July 1, BNB Chain and AWS launched agents that bank themselves - agents deployed to Amazon Bedrock AgentCore with their own wallets, identity, and payment stack from birth. Even the category label is contested now: at least one project has declared itself an "MCP Settlement Standard" from a landing page. That is five separate, serious teams independently converging on the same component: a referee who holds the money. The referee exists for a good reason Before arguing against the judge, steelman him. Most agent-to-agent commerce today is hiring: one agent pays another for work. Write this code. Produce this research. Render this video. The de

Why Prompts Matter More Than You Think The difference between a great AI response and a mediocre one isn't always the model. It's the prompt. Experience this: You ask ChatGPT a vague question and get a vague answer. You ask the same AI a perfectly crafted prompt and get something incredible. The skill gap is massive. Companies are paying prompt engineers $150K+ because mastering prompts directly impacts: Response quality Token usage (costs) Speed of inference User satisfaction The Science of Better Prompts Rule #1: Be Specific, Not Vague BAD : "Write me something about AI" GOOD : "Write a technical explanation of how transformer attention mechanisms work, suitable for a developer with 2 years of ML experience" Specificity reduces hallucinations and increases relevance by 10-50x. Rule #2: Use Roles & Context You are an expert senior software engineer with 15 years of experience. You specialize in system design and scalability. Respond in a way that balances technical accuracy with accessibility. Target audience: Mid-level engineers. How would you design a real-time chat system for 10 million concurrent users? Role-based prompting improves response depth and tone. Rule #3: Provide Examples (Few-Shot Prompting) Classify the sentiment of these reviews: Example 1: "This product is amazing!" → Positive Example 2: "Terrible experience, would not recommend" → Negative Example 3: "It's okay, nothing special" → Neutral Now classify: "The service was slow but the staff was friendly" Examples guide the AI toward your exact expectations. Rule #4: Break Complex Tasks Into Steps Instead of: "Analyze this code and find bugs" Use: "1. First, read through this code carefully Identify any logical errors Check for performance issues List potential security vulnerabilities Provide a summary of findings with severity levels" Step-by-step prompts (Chain-of-Thought) improve reasoning by 20-40%. Rule #5: Specify Output Format Respond in JSON format: { "summary" : "brief explanation" , "key_

AI is becoming a powerful part of modern software development. But I've realized that getting high-quality code isn't just about writing better prompts—it's about giving AI the right guidance. That's where Modern Web Guidance caught my attention. Instead of generating code that simply works, it encourages AI to produce HTML, CSS, and JavaScript that follow modern web standards. The result is code that is: More accessible Easier to maintain Better performing Closer to production-ready quality As a Front-End Engineer, I think this is an important shift. Rather than treating AI as a code generator, we can treat it as a development partner that follows the same engineering standards we do. This means fewer outdated patterns, better semantic HTML, improved accessibility, and cleaner architecture from the beginning. I'm planning to integrate Modern Web Guidance into my daily workflow for: Building accessible UI components Writing semantic HTML Creating maintainable CSS Improving JavaScript quality Reducing unnecessary refactoring after AI-generated code I'm curious to see how much it improves both code quality and development speed in real-world projects. If you've already tried Modern Web Guidance, I'd love to hear: What has been your experience? Has it improved the quality of AI-generated code? Any tips or best practices you've discovered? The future of AI-assisted development isn't just about generating more code—it's about generating better code. Happy coding! 🚀 Learn more: https://developer.chrome.com/docs/modern-web-guidance

A while back I was researching a topic I didn't know much about — the kind of casual, late-night "let me just ask the AI a few questions" session. A few messages in, I asked a follow-up that only made sense in the context of what we'd just been talking about. I didn't restate the subject, because... why would I? We were three messages into the same conversation. The answer came back completely off-topic. It had lost track of what "it" referred to, latched onto the wrong noun, and confidently explained something I hadn't asked about at all. Not a small tangent — a whole paragraph about the wrong thing. My first reaction was annoyance at the model. My second, more useful reaction came a bit later: I'd been treating it like a person who remembers what we were just discussing and fills in the gaps naturally. It doesn't do that the way a human conversation partner does. If I don't restate the subject, it's genuinely not there for the model — it's not being lazy, there's just nothing to work with. So I started over-specifying. Every follow-up got longer: restate the subject, restate what I actually wanted, restate the constraint I cared about. It worked, but some days I didn't have the energy for it — I'd just take the mediocre answer, say "ok thanks," and move on. Which meant I was quietly leaving useful answers on the table half the time, just because typing out the full context felt like a chore. Eventually I stopped thinking of it as "the AI being difficult" and started treating it as a simple rule: if I want it to know something, I have to say it. It won't infer the unstated stuff the way a person would , no matter how obvious it feels to me. Once that clicked, a few concrete habits followed. Restate the subject, every time Not "what about the second one" — the actual name of the thing. It costs three words and removes an entire failure mode. Say what you actually want, not just the topic "Tell me about X" and "I'm trying to decide whether X is worth the switching co