AI 资讯

The federal agency says it will temporarily schedule the drug, which has been called “gas station heroin,” as a controlled substance—a boon for MAHA and the mainstream kratom industry.

Coding agents don't have long-term memory. But you do have months of full-fidelity agent transcripts stored on your machine. A simple solution that goes a long way: ingest those transcripts and logs into a structured SQLite database, then search them with ranked text match. Everything is fully local and doesn't require anything fancy like a graph database or hosted memory service. This is the idea behind ctx, a Rust CLI that handles the ingestion and searching. We give our agents a skill that te

Create your own Mac apps by chatting with AI Discussion | Link

Nearly half a century ago, the free software movement made a demand that was both technical and moral: Users should have the freedom to understand, run, modify, and share the software on which they depended. It was a demand born from practical life with machines. A printer that couldn't be fixed. A program that couldn't be studied. A system that asked its users to accept dependence as the price of progress. That belief shaped modern computing and gave us the tools and norms that made the internet, open infrastructure, and collaborative software development possible. Today, that belief faces its hardest test. The technology has changed, but the warning signs are familiar. In 1980, at the MIT AI Laboratory in Cambridge, Massachusetts, a new Xerox 9700 printer was installed. The previous printer had come with source code that could be modified, inspected, recompiled, and reinstalled. Richard Stallman had changed that software to message users when their print job was done or when there was a jam, a small but meaningful feature since the printer sat several floors away. The new printer arrived with software preloaded and installed, no source code available, no way to modify it. If you needed help or new features, you hoped and prayed Xerox would listen. That loss of agency, alongside other anti-consumer shifts in early software, helped push him toward GNU and the free software movement: the belief that software should be free as in freedom, free to inspect, run, study, modify, understand, and redistribute. AI and inference services today are not too dissimilar. Closed frontier intelligence can make entire companies, governments, developers, and communities dependent on systems they cannot inspect, reproduce, modify, or meaningfully contest. At the dawn of this AI moment, we were promised unfettered intelligence across our products, companies, and codebases. We were told we'd be free to build whatever we wanted. At first, with tab completions. Then whole function blocks.

Author: Tobie Morgan Hitchcock Today we're launching Scale, a new tier of SurrealDB Cloud built for the workloads you can't afford to have go down. Our first tier, Start, was designed for building and shipping fast. Scale is designed for what happens next: production traffic, uptime commitments, and the kind of resilience your users never notice because there are always available nodes. It's the tier for teams running SurrealDB as the scalable context layer behind real applications and AI agents in production. What you get with Scale Scale is about one thing: keeping your database available and consistent under real-world conditions. Highly-available, fault-tolerant clusters. Scale runs your database as a multi-node cluster designed to survive node and infrastructure failures without dropping writes or losing consistency. A single point of failure is no longer a single point of downtime. Multiple availability-zone deployment. Your cluster is distributed across multiple availability zones, so even the loss of an entire zone doesn't take your database with it. Traffic keeps flowing while the cluster recovers in the background. Horizontal scale. As demand grows, Scale grows with it. Add capacity by scaling out across nodes rather than being capped by the size of a single machine. Start with three nodes, and keep adding to scale your application or agent's needs. See more information about SurrealDB Cloud Scale architecture here . Built on SurrealDS Scale is powered by SurrealDS , SurrealDB's distributed storage engine and the foundation that makes all of this possible. SurrealDS is a new generation distributed storage architecture, rethought from first principles. Instead of coupling storage to compute on a single box or to a proprietary cloud tier, SurrealDS embeds consensus directly in SurrealDB nodes and separates the two layers cleanly. Here's what that architecture gives you. Architecture overview Compute and storage separation. Scale compute for QPS and storage f

by Peter Yang, Behind the Craft Today, I want to share 18 hot takes on where I think the AI market is headed. AI is in a weird place right now. The government is restricting access to frontier models, enterprises are becoming conscious of token costs, and everyone’s trying to rebuild their product for agents first instead of humans. I’ve interviewed dozens of AI leaders and spent far too much time following these topics on X/Twitter. Here are 18 hot takes on where I think AI is headed next: The frontier-only AI stack is collapsing The AI super app era is here Traditional software risks becoming a dumb pipe for agents Cloud agents and collaboration are the next wave The Frontier-Only AI Stack Is Collapsing Tokenmaxxing at frontier API prices makes no sense. Uber burned through its entire 2026 AI budget in 4 months, Microsoft moved engineers off Claude Code due to cost, and companies are realizing that running everything on frontier models can get expensive fast. Tokenmaxxing makes sense when you’re on a subsidized $200/month plan but is unsustainable at API rates. Companies will rely on a portfolio of models. Coinbase recently cut its AI spend nearly in half by switching engineers to Chinese open-source models like GLM and Kimi. Airbnb and Pinterest have done the same with Alibaba’s Qwen models. I believe that this will be the default path forward — using frontier for high-stakes work and cheaper models for everything else. China’s open-source strategy is working. Chinese models are taking market share from frontier models at US companies. China is also building the full AI stack — from energy (e.g., solar, nuclear) to data centers to domestic chips. The Chinese government is planning a $295B investment in AI data centers with at least 80% of the chips built domestically. Frontier labs are in a catch-22 situation. If they release great open-source models, they might undercut their own frontier API revenue. If they gate the best models behind a trusted list, companies

What happens when a machine no longer needs to be trained to see something new? That's the quiet question sitting underneath this week's news, buried next to a less invasive brain implant and a handful of robots getting tougher for the real world. Neuralink says it's completed its first "transdural" brain implant, a surgical approach built to reduce trauma during the procedure. As someone who spends a lot of time thinking about how you get sensors close to a human eye without hurting anyone, I find these less-invasive-implant strategies worth watching, because the surgical-risk problem is basically the same one we wrestle with in ophthalmic hardware. Vision is getting less invasive too, in its own way. Roboflow rolled out text-prompt object detection built on SAM3 (Meta's latest segmentation model): you type the class of object you want "forklift," "cracked tile," whatever, and it returns boxes and masks without you collecting a single training image first. That's a real shift. For most of computer vision's history, teaching a model to recognize something new meant labeling hundreds of examples before you could even start; this collapses that step into a sentence. The same week brought several applied builds using the same detect-then-orchestrate pattern: a drone system that patrols for intrusions, a pipeline that inspects transmission lines for damaged cables, and an airport tool that spots foreign debris on the tarmac. The Robot Report's roundup of June's biggest robotics stories leaned heavily on humanoid robots companies going public, new deployments, and production milestones stacking up faster than would have seemed plausible a few years ago. Apptronik unveiled its Apollo 2 humanoid alongside a dedicated data-collection facility built so the robot keeps learning after it's deployed, not just during initial training which quietly answers one of the harder questions in robotics: how do you keep a system improving once it's out of the lab? X Square Robot raised e

This tutorial was written by Néstor Daza . This is the second article in a series about building Claudius , my own Claude-based chatbot ( Github ). The prologue made the case for building it, and for choosing MongoDB as its foundation. Open the conversations collection in Claudius’ database and you find the usual fields of a thread header but nothing else: a userId , a title , some timestamps , and so on, but no array of messages, no messages collection sitting beside it either! The text of every conversation lives somewhere else entirely, in the LangGraph checkpointer, which I wire up later in this series. This absence is a modeling decision, and how I came up with the database schema for my chatbot is the theme of this article. If you come from a relational background, you're used to modeling the data first when designing a database. For a project like this, you would start by finding the entities and normalizing them, and the final schema would come out of the data's structure: a conversations table and a messages table with a foreign key between them, because that is what the data looks like. Document modeling runs the other way. You start from how the application reads and writes, and the shape of the document follows the access patterns. Claudius never reads conversation messages without the agent's full working state wrapped around them, and that state is persisted using the LangGraph checkpointer. A separate messages table would add nothing, since the app would always have to join it back to that state on every read. The access pattern says the messages belong with the agent state, so that is where they go, and conversations are left as the lightweight header the list view actually needs. That inversion, modeling around use rather than around the data, runs through everything below. Schema-flexible is not schemaless This is the misconception lots of people often carry, and it is worth killing on the way in. A document database does not mean no schema; it mea

Communities love your brand - Our AI team finds them for you Discussion | Link

Zero-Knowledge Proofs (ZKPs) let an untrusted proved show that computation was executed correctly without revealing the inputs to the verifier. However to prove anything, the computation first has to be expressed as a circuit: a system of polynomial equations (constraints) over a finite field. Circuits are the assembly language of zk and every constraint costs prover (and sometimes verifier) time, so production circuits are aggressively hand-optimized. Over the last months, we have been experime

Frameworks like Lean Six Sigma and business process management (BPM) first gained traction because they promised clarity in the chaos—a structured way to bring order to messy, sprawling operations. Lean Six Sigma emphasized statistical rigor and quality control; BPM created end-to-end maps of how work should flow across departments. Both offered a repeatable way to…

By Hiral Shah, Senior Director, Product Management, Docusign A major recurring theme among the engineering teams at this week’s AI Engineer World’s Fair in San Francisco is the push to move specialized AI models out of research and directly into high-volume production. At Docusign, that optimization challenge happens at massive scale: we handle millions of transactions daily and have nearly 1.9 million customers in over 180 countries. Organizations have historically lost significant value every year to the friction, delays, and missed obligations that come from treating these agreements as static documents rather than live sources of business data. Much of that trapped value sits inside tables: the pricing schedules, SLA obligations, and contractor rate cards that define enterprise relationships but are often the hardest part of a contract to extract accurately. To solve this, we integrated NVIDIA Nemotron Parse , a vision-language model purpose-built for document understanding, directly into our document processing pipeline. Docusign and NVIDIA took the AI Engineer World’s Fair stage this week to give attendees a look at how the architecture works under the hood. Here’s what that looks like: Why Contract Tables Break General-Purpose AI Contracts routinely contain merged cells, multi-page structures, mixed formatting, and nested layouts that general-purpose vision language models (VLMs) and broad AI models weren't designed to handle. The result is inaccurate extractions that require manual correction, slowing down the workflows they are intended to accelerate. Our teams watch this operational friction play out across real enterprise scenarios every day: System Downtime: When a critical system goes down, operations teams need to know immediately which SLA notification requirements apply and to whom. Resource Tracking: When business stakeholders ask legal what hourly rate was agreed to in a contractor engagement, the answer is often buried deep inside a rate card tabl

In my previous article, I introduced the NeNe series: a family of small, self-hosted business tools for teams operating in Japan. Previous article: https://dev.to/hideyukimori/i-am-building-self-hosted-business-tools-for-small-teams-in-japan-4i26 This article is a deeper look at one of those tools: NeNe Records . Repository: https://github.com/hideyukiMORI/nene-records NeNe Records is an API-first typed CMS and flexible entity platform built on NENE2 , my small PHP framework for AI-readable business APIs. It is not trying to be a WordPress clone. It is not trying to run WordPress plugins or themes. The goal is different: manage business data and public content through typed schemas, documented APIs, and clear AI tool boundaries. Why not just use WordPress? WordPress is useful. It has proven that a generic content model can support blogs, pages, shops, media, and many small business workflows. But when I think about business data, a few problems keep coming back: untyped metadata plugin-specific data shapes hooks and filters that can change behavior from many places API contracts that depend heavily on plugins AI integrations that may not know where the real application boundary is The postmeta model is flexible, but it often becomes stringly typed storage. That is fine for many websites. But for business data, I usually want the API to know more: this field is text this field is an enum this field is an image this field is a relation this field is required this record belongs to this organization this operation requires this role That is the space where NeNe Records lives. Typed records instead of metadata chaos The core model is simple: Entity Type -> Field Definition -> Record An Entity Type defines what kind of data exists. Examples: posts pages products events internal documents A Field Definition describes the shape of a field: text markdown html blocks int enum bool datetime image file relation A Record is the actual data. The important part is that the schema

The latest Puppet Enterprise releases are out and this one has a huge load of improvements, fixes, and security patches included! Puppet Enterprise (PE) 2025.11 released! The full PE 2025.11 release notes are always the best way to get a full detail on what has changed, but here are some highlights of PE 2025.11! Certificate Authority (CA): Database-backed Storage This new optional feature adds support for storing CA data in a PostgreSQL database instead of the file system. This improves performance and reliability and introduces API-driven capabilities and enhanced backup and recovery handling. PostgreSQL 17 Supported PE-managed installations will automatically upgrade from verson 14 to 17 as part of the upgrade process, or you can update yourself before upgrading to PE 2025.11 Infra Assistant Goes GPT-5 GPT-5 series models are now running under the hood of Infra Assistant, improving the quality of responses and the consistency for queries. Advanced Patching Enhancements The advanced patching feature now has improvements across a variety of areas New puppet_run_concurrency setting allows you to get better performance out of patch group enrollment Improved validation of scheduled and immediate jobs to reduce risk of unintended or skipped executions. Cron scheduling has better user experience and improved validation across features. New configurable option to enable Puppet to run after patch jobs to refresh pe_patch facts New Endpoints for Classifier and Activity Service APIs The Classifier API introduced new tags , add-tags and remove-tags endpoints to manage node group tags. The Activity service API now has subscriptions endpoints to create subscriptions, list subscriptions, or fetch/delete a specific subscription. Agent Platform Updates, Resolved Issues, and Security Fixes The macOS 26 platform is now supported for both ARM and x86_64, while support has been removed for Ubuntu 18.04 and Ubuntu 20.04. Nearly 60 CVEs were addressed in this release, along with many r

by Sergey Karayev, cofounder @ Superconductor Recently, my wife and I sat down to plan an upcoming trip. Naturally, we each asked an AI. Trouble was, I had my chat and she had hers, and they knew nothing about each other. So we served as couriers between chatbots: her idea pasted into my chat, my hotel booking screenshotted into hers, the itinerary reconciled by hand in a Google Doc. I bring this up because your team probably works the same unfortunate way: each person in their own chat or coding agent session, with precious little shared. I've been building software with the same set of people for over a decade. In the past year, we all got a superpower: coding agents that can do extremely impressive things. But each one (Claude Code, Codex, Cursor, etc.) was built for a single player. That's fine and dandy if you're vibe-coding your own little app. It's just you and Claude, and it's absolutely magical. But put that same agent on a team and the magic fades quite a bit. The model is no longer the bottleneck. Coordination is. You don't know who's working on what. You can't see that an agent already tried the approach you're about to attempt, and abandoned it. You spend an hour re-deriving context that a teammate has, because it's trapped in their private chat. Now let me tell you of a better way. On the Superconductor team, every coding agent session is in the cloud, open to anyone else on the team to join. What this enabled was transformative. Code review improved first. My teammate reviews my work by joining the session I built it in. The session holds the full history of decisions, including the dead ends. Instead of Slacking me "why'd you name it this way?" she asks the agent. She gets her answer, and I never waste time answering. She also doesn't have to check out the branch locally — the live app preview in the cloud sandbox does the job. Handoffs became easy. If I have to pass a feature to a teammate, he picks it up with full context: what's done, what's left,

Digital Signatures: Format, Certificate, and Validation Policy Are Not the Same Thing The right move when a digital signature fails validation is don't look at the cryptography first . I know that sounds backwards. If the algorithm is RSA-2048 and the certificate chain is intact, why would validation fail? Because a signature can be cryptographically perfect and still get rejected by the validator. The problem isn't the hash or the private key — it's the format, the wrong certificate, or the validation policy the system is applying. My thesis is simple: most errors that look cryptographic in digital signatures are actually upper-layer errors — incompatible format, a certificate that doesn't meet the required profile, or a validation policy that the issuer and receiver never aligned on. And confusing those three layers has a real cost: debugging time wasted in the wrong place. The Real Mess: Three Layers People Keep Mixing Up When a digital signature fails validation, the typical mental sequence is: "Is the algorithm correct? Does the private key match the public one? Did the certificate expire?" Those are reasonable questions, but they're all in the same layer. The problem is there are three distinct layers, and each one can fail independently. Layer 1 — Signature Format The format defines how the signature is packaged together with the signed data. CMS/PKCS#7 is not the same as XAdES, PAdES, or JAdES. Each has variants: BASELINE-B , BASELINE-T , BASELINE-LT , BASELINE-LTA . Choosing CAdES-BASELINE-B when the receiver expects XAdES-BASELINE-LT produces a rejection that has nothing to do with the cryptographic algorithm. The public documentation for DSS (Digital Signature Service) from the European Commission describes these variants in detail. DSS is the reference library for eIDAS-compliant signatures, and its documentation is one of the most complete and verifiable resources publicly available. Layer 2 — Certificate The certificate is the signer's identity, but it

When the enemy is in distress, exploit the opportunity to seize advantage. — The 36 Stratagems, Loot a Burning House Who's Leo — In the last story , he was CoreStack's backend lead — the guy who built the core system alone over five years with zero P0 incidents. Then a new CTO named James showed up, spent $8M on his old employer's product, and laid off Leo's entire team. Thirteen days later, that $8M AI system collapsed — three agents fighting over context, OOM taking down six GPU servers, a 37% order duplication rate, and 2,300 customer complaints. Leo pulled the old system off his laptop, flipped one line of Nginx config, and restored service in thirty seconds. The CEO called him at 3 AM begging him to come back. He came back. Three conditions: kill the paid AI product, AI assists only — never touches the primary pipeline — and engineers decide the architecture, not the guy writing checks. The CEO agreed to all of it. So who's Leo now: CoreStack's CTO. Technically confident to the point of arrogance. Zero talent for upward management. No idea how many people he pissed off on the board with those conditions. Doesn't care. He only knows one thing — the system he built is still running. That's all the proof he needs. Then a Slack message cut him off. The Signal 12:47 AM. CoreStack's CTO gets a Slack notification. The account has no profile picture, no display name, no status. Account creation timestamp at the bottom — 00:43. Four minutes old. Seven characters: Check CodeForge's status page. Leo taps it open. CodeForge's status page is all red. Payment Routing — Major Outage. Investigating. All customers affected. Status has been active for approximately 3 hours. He pulls up CoreStack's CRM. The sales team's prospect list has ShopStream at #2 — a potential whale, with "Current Provider" reading CodeForge. E-commerce platform doing 470,000 transactions a day . An hour of downtime costs them $210,000 . If this drags on until morning? He doesn't want to do the math. Core

Early-stage firm Magnify Ventures has raised a $46.6 million Fund II from LPs including Melinda French Gates’ Pivotal Ventures