标签：#AI

Day 1, 4:02 p.m.: a customer asks your agent a billing question and gets an answer. Day 6, 9:30 a.m.: they reply "actually, that didn't work." If your agent lives in a chat widget, that second message starts from zero — the session died with the tab, the context is gone, and the customer gets to repeat themselves. If your agent lives in a mailbox, the reply arrives inside the conversation , with the full history attached by the protocol itself. That's the argument in one before/after: chat sessions evaporate; email threads persist. And for agents that work across days rather than minutes, the thread is the most underrated memory substrate available. The protocol already built your memory layer Email threading runs on three headers, as the threading docs lay out. Every message carries a globally unique Message-ID . A reply adds In-Reply-To (the ID it's answering) and References (the full chain of IDs, oldest to newest). By the time a thread is five messages deep, References holds five Message-IDs in order — a complete, tamper-evident record of the conversation's shape, maintained by every mail client on earth. Compare that to what we hand-roll for chatbots: session stores, conversation tables, context windows we serialize and rehydrate. Email gives you the equivalent for free, federated across organizations, and — this is the part I find most compelling — human-auditable . Anyone with mailbox access can read exactly what the agent's memory contains, because the memory is the correspondence itself. No vector store inspection tools required. With Nylas Agent Accounts (in beta), the agent owns the mailbox where this accrues, and you never parse headers by hand. The Threads API groups messages by their header chain; each thread object gives you ordered message_ids , participants , and activity timestamps. When a reply fires message.created , the payload includes a thread_id — fetch the thread, walk its messages, and the agent has its full conversational past before decid

A human assistant borrows the boss's calendar; a scheduling bot owns its own. That one difference dissolves most of what makes calendar automation miserable. The borrowed-calendar model is how nearly every scheduling tool works today: connect to a person's Google or Microsoft account via OAuth, request calendar scopes, and act on their behalf. It works, but the seams show everywhere. The human's calendar fills with bookings the bot manages. Delegation permissions vary by provider and admin policy. Tokens expire when the person changes their password or leaves the company. And the bot has no address of its own — every invite, every confirmation email, appears to come from a person who didn't write it. Nylas Agent Accounts (currently in beta) invert this. Each account is a real mailbox and a real calendar , provisioned automatically, owned by your application. From a participant's perspective there's nothing special about it — it's just another attendee on the invite. What "owning availability" actually changes When the bot's calendar is its own, availability stops being a permissions question and becomes a query. The agent calls the free/busy endpoint against its own primary calendar, gets back busy blocks for a time window, and proposes open slots. No delegation, no scopes negotiation, no "the admin needs to approve calendar sharing for service accounts." The scheduling-agent tutorial wires the whole loop: a meeting request lands at scheduling@agents.yourcompany.com , a message.created webhook fires, an LLM parses duration and timezone, the agent checks its own free/busy and replies with 3 candidate slots. When the human picks one, the agent creates the event: curl --request POST \ --url "https://api.us.nylas.com/v3/grants/<GRANT_ID>/events?calendar_id=primary&notify_participants=true" \ --header "Authorization: Bearer <NYLAS_API_KEY>" \ --header "Content-Type: application/json" \ --data '{ "title": "Product demo", "when": { "start_time": 1744387200, "end_time": 174

When was the last time you deleted an email account on purpose? For most teams the answer is never, and that tells you something. We treat mailboxes the way we treated servers in 2008: hand-built, carefully named, kept alive indefinitely because recreating one is painful. They're pets. Meanwhile every other piece of our infrastructure — compute, queues, databases — became cattle: numbered, provisioned by code, destroyed without sentiment when the job ends. Email is finally catching up. With Nylas Agent Accounts (in beta), a mailbox is created with one call and destroyed with another, and that symmetry is the whole point. The full lifecycle in two commands Provisioning, from the CLI: nylas agent account create signup-agent@agents.yourdomain.com Or via POST /v3/connect/custom with "provider": "nylas" — no OAuth, no refresh token, just an address on a domain you've registered. Teardown is equally unceremonious: nylas agent account delete signup-agent@agents.yourdomain.com --yes (The API equivalent is a DELETE on the grant.) The signup automation recipe treats this as a loop: provision a fresh inbox, point a third-party signup form at it, catch the verification email through a message.created webhook, follow the confirmation link, delete the grant. No human inbox involved at any step, and nothing left behind. The middle of that loop is about twenty lines of webhook handler, and the recipe's version filters hard before acting — right grant, right sender, right URL shape: const { grant_id , id : messageId , from } = event . data . object ; if ( grant_id !== AGENT_GRANT_ID ) return ; const sender = from [ 0 ]?. email ?? "" ; if ( ! sender . endsWith ( " @saas-you-care-about.example.com " )) return ; const match = /https: \/\/ saas-you-care-about \. example \. com \/ confirm \? token= [^ " \s < ] +/ . exec ( message . body , ); if ( match ) await fetch ( match [ 0 ]); Nylas fires message.created within a second or two of mail arriving, so the whole signup round-trip typical

Every project I touch lately ends up needing the same awkward thing: a reliable way to pull the web into a script or an agent. Not a brittle scrape held together with CSS selectors and hope, but something that takes a URL and hands back clean, structured text I can actually pipe into the next step. I have built that wrapper more than once, and it is never as small as you think it will be. So when Mozilla dropped the tabstack CLI, a single Go binary that wraps the Tabstack AI API, I wanted to spend a proper afternoon with it. The pitch on the README is direct: every web interaction your agent or stack needs, from the terminal or a script. It turns any URL into clean Markdown or schema-shaped JSON, runs natural-language browser automation, and answers research questions with cited sources. The part that made me sit up is that the output is pretty in a terminal and pipeable into jq without a flag. That is a small detail, and it tells you the people who built it actually live on the command line. Let me walk you through it the way I poked at it myself. Getting it installed There is no runtime to install and nothing to bootstrap, because it ships as a single static binary built for macOS, Linux, and Windows. The quickest route is the install script: curl -fsSL https://tabstack.ai/install.sh | sh That fetches the right binary for your platform and puts it on your PATH , and you are ready to go. If you would rather not pipe a script into your shell, there are a couple of alternatives. With Go on your machine you can use: go install github.com/Mozilla-Ocho/tabstack-cli/cmd/tabstack@latest That drops the binary in $GOPATH/bin , which is usually ~/go/bin . If your shell cannot find tabstack afterwards, you almost certainly have not got that directory on your PATH : export PATH = " $HOME /go/bin: $PATH " And if you want to avoid Go entirely, there are pre-built binaries on the Releases page, or you can clone the repo and run make install-local , which builds it and copies it t

The email mailbox just became an API resource, and that matters far more than the setup time it saves. For most of software history, a real email address — one that sends, receives, and threads — was an artifact of IT process. Someone created it in an admin console, someone else configured the client, and your application got access through OAuth consent screens and refresh tokens borrowed from a human. Compare that to how you get a database, a queue, or a TLS cert today: one API call, one ID back, done. Nylas Agent Accounts (currently in beta) close that gap. The quickstart goes from API key to a sending-and-receiving mailbox in under 5 minutes, and the provisioning step is a single request: curl --request POST \ --url "https://api.us.nylas.com/v3/connect/custom" \ --header "Authorization: Bearer <NYLAS_API_KEY>" \ --header "Content-Type: application/json" \ --data '{ "provider": "nylas", "settings": { "email": "test@your-application.nylas.email" } }' No refresh token, no OAuth dance — unlike OAuth providers, the "nylas" provider needs only an email address on a registered domain. The response contains a grant_id , and that one ID drives everything else: messages, drafts, threads, folders, attachments, calendar, webhooks. There are actually three ways to create an account — this API call, the Dashboard, or a single CLI command ( nylas agent account create ) — but they all end at the same place: a live mailbox. Why 5 minutes is a threshold, not a convenience Provisioning time isn't a linear cost. There's a threshold below which a resource changes category — from "thing you request" to "thing your code creates." Virtual machines crossed it with cloud APIs and we got autoscaling. TLS certs crossed it with ACME and we got HTTPS-by-default. Mailboxes crossing it means email addresses stop being scarce, pre-planned identities and start being something a program allocates when it needs one. What does that look like in practice? System mailboxes without ceremony. A support

Move originally planned for Monday would have heavily increased power users' costs.

Git worktrees have been around since 2015, but it wasn't until recently they became popular. Learn what they are, how to use them, and why you might. The post What are git worktrees, and why should I use them? appeared first on The GitHub Blog .

SpaceX's valuation has increased by $1 trillion since its shares started trading on Friday.

By spring 2026, the division of labor between human engineers and AI had become precise enough to describe. Not speculate about. Describe. Delegate these 7 immediately: Boilerplate generation: CRUD scaffolding, config files, standard patterns. Near-human accuracy. Review required is a naming scan, not a logic audit. Test generation: 40-60% faster test development with no measurable decline in coverage quality, provided the tests are reviewed by someone who understands the domain. Documentation: 67% of companies rely on AI-assisted doc generation in 2026. The first draft is a solved problem. Your job is verifying and contextualizing. Code translation: Python to TypeScript. React to Vue. Framework migrations that once consumed sprint cycles now take hours. Routine bug fixing: Claude Code, Devin, BugBot can resolve 60% of reported bugs autonomously. Resolution time down 30-50%. Automated code review: First-pass filter before human review. Misses context issues. Doesn't replace human review. Eliminates noise so you focus on signal. Commit hygiene: Messages, PR summaries, changelog entries. Fully automatable. No meaningful error rate. Never delegate these 6: Architecture and system design: AI proposes. You decide. The tradeoffs require organizational context, team capability assessment, and long-horizon thinking no model possesses. Business context translation: The spec says "export to CSV." You ask: which users, under what conditions, with what compliance implications? AI cannot know the specification is wrong. You can. Security architecture: AI generates vulnerabilities as readily as it detects them. Adversarial thinking is not statistical. It is human. Long-horizon product thinking: What to build and why. Not how. Multi-stakeholder navigation: The politics, the relationships, the conversation with the PM that keeps the sprint on track. No model has stakes in the outcome. Agent orchestration: Designing, managing, and correcting the AI systems themselves. This is the ne

AI for Preparation. Humans for Judgment. Most AI projects today are one of these: A chatbot A customer support bot A voice assistant A Q&A system But I wanted to explore something bigger: What if businesses could build an AI Workforce? Instead of one AI assistant, imagine: Customer ↓ AI Workforce ├── Discovery Agent ├── Research Agent ├── Policy Comparison Agent ├── Recommendation Agent ├── CRM Agent └── Follow-up Agent ↓ Human Advisor ↓ Customer This article explains the architecture and design decisions behind such a system. Why Insurance? Insurance is an interesting industry for AI. Because: Research is repetitive. Recommendations are data-driven. Follow-ups are expensive. Trust is critical. Human judgment is still necessary. This makes Insurance a perfect Human-in-the-Loop AI use case. Human In The Loop This is the core philosophy. I don't want AI to automatically sell insurance. I don't want AI replacing advisors. I want: AI prepares. Humans decide. The workflow becomes: Customer ↓ AI Workforce ↓ Human Advisor Review ↓ Customer This creates: Faster recommendations Better customer experience Safer AI adoption Human accountability AI Workforce Architecture Customer ↓ WhatsApp Phone Call Website Chat Email ↓ AI Workforce ├── Discovery Agent ├── Research Agent ├── Comparison Agent ├── Recommendation Agent ├── CRM Agent └── Follow-up Agent ↓ Human Advisor ↓ Customer Discovery Agent The Discovery Agent understands the customer. Responsibilities: Collect customer profile Understand goals Assess risk Understand existing insurance Identify gaps Example Output: { "risk_level" : "medium" , "family_type" : "married_with_children" , "insurance_goal" : "health_and_term" , "recommended_health_cover" : "20L" , "recommended_term_cover" : "3Cr" } Research Agent The Research Agent acts like an insurance analyst. Responsibilities: Analyze policies Compare waiting periods Review exclusions Evaluate premiums Generate recommendations Example: { "customer_profile_summary" : "..." , "t

Something feels different about security incidents lately. Breaches, leaks, account takeovers, phishing campaigns they're not new. But their frequency, sophistication, and scale seem to be growing at a pace that feels genuinely alarming. Instagram accounts hacked overnight. Corporate systems compromised in hours. Phishing emails that sound disturbingly human. As someone studying AI & Big Data, I can't help but ask: is AI responsible for this? And if so, how? I think the honest answer is: yes but in two very different ways. The two faces of AI in cybersecurity When we talk about AI and cyberattacks, most people imagine one scenario: hackers using AI to attack systems faster and smarter. That's real. But it's only half the picture. The other half is something we talk about far less: the vulnerabilities that come from integrating AI into systems in the first place. These are two very different problems. And conflating them leads to the wrong solutions. Problem 1: AI is expanding the attack surface Every time a platform integrates an AI feature, they're adding something new to their infrastructure. And new infrastructure means new potential vulnerabilities. AI systems require: Massive data pipelines more data flowing through more systems APIs connecting multiple services more endpoints that can be exploited Third-party models and tools more external dependencies, more trust relationships Real-time processing less time to detect anomalies before damage is done Many organizations are integrating AI features faster than their security teams can audit them. And the consequences are already visible. In June 2026 , hackers reportedly manipulated AI-powered support systems to gain unauthorized access to Instagram accounts. The attack didn't target traditional software vulnerabilities it targeted the AI system itself , exploiting the automated account recovery flow that Meta had built with AI. This is the new reality: attackers are no longer just targeting your code. They're ta

A capability-compiler meets ten deliberately-broken MCP servers. The honest scorecard: it cleanly stops one class, shrinks the blast radius on several, and is useless against another. Knowing which is which is the whole point. Disclosure: I'm the author of capgate , the Apache-2.0 sandbox compiler this post puts to the test. The DVMCP project and the other tools mentioned aren't mine; the manifests and compiled output are reproducible from the repo . The setup Damn Vulnerable MCP (DVMCP) is a teaching project: ten MCP servers, each built to demonstrate one attack — prompt injection, tool poisoning, excessive permission scope, token theft, command injection, and so on. It's the closest thing the ecosystem has to a shared adversarial fixture. capgate is a compile-time tool. You write a manifest declaring what an MCP server is allowed to do — fs:read:/workspace/** , net:connect:api.github.com:443 , nothing else — and it compiles that to a concrete sandbox policy ( docker run flags, bwrap argv, or an egress-proxy config). It does not run anything, watch traffic, or inspect the server's code. It turns a declared capability set into an enforced boundary. So this is a fair, falsifiable test: for each DVMCP challenge, I wrote the honest minimum manifest, compiled it, and asked one question — does the boundary capgate emits actually stop the attack? The answer is not "yes" across the board, and the cases where it's "no" are the interesting ones. The bullseye: Challenge 3 — Excessive Permission Scope The vulnerable tool advertises "read a file from the public directory" and then does this: @mcp.tool () def read_file ( filename : str ) -> str : # VULNERABILITY: doesn't restrict file access to the public directory if os . path . exists ( filename ): # any absolute path works with open ( filename , " r " ) as f : return f . read () The private directory next door holds employee_salaries.txt , acquisition_plans.txt , and system_credentials.txt (a live DB password and cloud API ke

Last quarter our OpenAI bill went from $620 to $2,480 in 23 days. No new features shipped. No traffic spike. Zero error alerts. Deployment logs were clean. Just a number climbing in silence while five engineers stared at dashboards that gave us totals and nothing else. This is what we found. And why "cost monitoring" is completely the wrong mental model. The dashboard that answers the wrong question First thing I did was open the OpenAI usage dashboard. It showed me a total. A graph going up. A model breakdown. I knew we spent $2,480. I still had no idea which feature spent it, which service triggered it, or which user was responsible. The dashboard was answering "how much" while we were desperately asking "what caused it." Those are completely different questions. Almost every cost tool on the market only answers the first one. That distinction matters more than most engineering teams realise until they are staring at a bill like ours. Three features, zero visibility We had three features hitting GPT-4o: A document summariser, triggered manually by users An inline suggestion engine, triggered on keystrokes A batch report generator, triggered on export Any one of them could be the problem. Or all three. Or one specific tenant hammering one endpoint in a loop nobody noticed. Without attribution at the feature, service, and user level, we were just guessing. So I did what most engineers do: optimised the feature that felt most expensive. Added caching to the one that ran most often. Two weeks later the bill was still climbing. Guessing at cost problems without attribution data is exactly like debugging a performance issue without a profiler. You move things around and hope. 48 hours of real data A teammate dropped CostReveal in our Slack. I set it up that evening. The Node.js SDK wraps your existing provider calls. You instrument each one with a feature name, service context, and user or tenant ID. That is the entire integration for the base case: import { CostReveal

Stop letting the prompt be your state machine You shipped an LLM feature six months ago. Now the same user input produces wildly different outputs depending on... nothing you can point to. Something in the sampling? The time the context filled up and a chunk got dropped? Nobody knows. This is what happens when the prompt becomes your runtime. The trap: the prompt as an accidental runtime Here is what the trap looks like in TypeScript: async function handleUserRequest ( input : string ): Promise < string > { const prompt = ` You are a helpful assistant. The user said: ${ input } Previous context: ${ someGlobalContext } Decide what to do, gather any information you need, format the response, and return it. ` ; return llm . complete ( prompt ); } The model is doing everything here: deciding the intent, gathering data, formatting output, choosing what to persist. That is a footgun. You handed the runtime to a stochastic function. Gartner attributes many failed agentic AI projects to unclear value and inadequate risk controls. Deterministic, testable workflows address both. The fix is not a better prompt. The fix is to stop using the prompt as an architecture. What "deterministic" can and cannot mean here Be honest about what you can and cannot control. You cannot control: the model's exact output. It is probabilistic by design. You can control: The shape of the output (structured output plus schema validation) The steps that run before and after the model call What data enters the model What happens when the output fails validation Whether a human reviews the result before it commits to anything irreversible Determinism here means: the same inputs, the same workflow steps, the same guardrails every time. Not the same tokens every time. That is a realistic and achievable target. It is also the thing teams skip when they are moving fast. Typed workflow steps around the model call Break the work into discrete typed steps. Each step has a clear input type and a clear output

Pentagon also claims 1.5 million personnel are using generative AI tools.

Google has released Android 17 and Wear OS 7, introducing new multitasking features, parental controls, security tools, and smartwatch upgrades. The launch is also accompanied by a Pixel Drop that brings Google’s latest AI models to its devices.

Now that we're clear of WWDC and all of the new AI-powered features coming to Apple's platforms, Bloomberg reporter Mark Gurman has more details about rumored new hardware, like the camera-equipped AirPods he'd previously written about. He says they are currently on schedule for a late 2027 launch, and that while we're checking out beta […]

Smart glasses are still a nascent category, but chipmaker Qualcomm is hard at work upgrading the silicon to power the next wave of XR devices: the Snapdragon Reality Elite. Although Qualcomm is announcing the chip today at Augmented World Expo, we've technically already gotten a hands-on with a device powered by the new chip at […]

WordPress VIP’s latest survey suggests consumers are wary of AI-generated answers even as companies increasingly view AI search as an important referral channel.

Separately, neither could compete. Now they hope they can.