标签：#AI

In the current epoch of Artificial Intelligence, the industry remains singularly preoccupied with the "Model" — obsessing over the raw parameter scales of the latest LLMs or the specific benchmark performance of a new transformer variant. However, at Informatiqs, we shift the lens. We recognize that sustainable enterprise value is rarely derived from the model in isolation; instead, it emerges from the high-stakes architectural decisions and systemic orchestration that define its environment. As we launch our inaugural edition, we dissect a critical technological nexus: the convergence of Graph Neural Networks (GNNs), Generative AI, and the industrial-grade infrastructure of Google Cloud Platform (GCP). We argue that for complex enterprise datasets, the transition from flat vector embeddings in latent space toward non-Euclidean, graph-based relational intelligence is the primary differentiator for the next generation of resilient AI applications. 1. The Scientific Foundation: Exploiting Relational Inductive Bias Traditional Deep Learning architectures, such as Convolutional Neural Networks (CNNs) for images or Transformers for text, primarily operate on data structured as sequences (Euclidean space). While exceptionally powerful, these structures often fail to capture the topological nuances of real-world systems like supply chains, molecular structures, or fraudulent transaction webs where data is inherently non-Euclidean. Graph Neural Networks (GNNs) provide a framework for learning from data represented as nodes and edges. Unlike standard neural networks that process inputs in isolation, GNNs utilize a Message Passing paradigm. In this process, a node's internal representation is iteratively updated by aggregating information from its immediate neighbors. Instead of looking at a data point as a single row in a database, the GNN looks at who that data point "talks to" and how those connections define its identity. By utilizing Graph Attention mechanisms, we can fu

OpenAI is quietly testing a feature that lets ChatGPT users pay to undo their own usage limits. Hit the weekly cap on a $20 Plus plan and, for some users, a prompt now appears offering to restore the allowance to full for roughly $8. On the $200 Pro plan, the equivalent reset is reported to run up to about $80. The company never announced it; it was discovered by a subscriber who ran into it at the point of being locked out, and an OpenAI spokesperson later confirmed the company is exploring ways for capped users to buy more usage . The answer-first version: your flat monthly subscription now has a pay-to-continue button, and it shows up at the worst possible moment. The reset restores your usage to 100% and pushes the next weekly renewal about seven days out. It is cheaper than upgrading, which is the point — but it is also a new charge that did not exist a month ago, applied to a limit most users cannot see coming, offered at the instant they are least able to say no. What OpenAI is actually testing The mechanics, as reported, are straightforward. When a ChatGPT Plus subscriber exhausts their weekly message allowance, instead of only being told to wait, some accounts now see an option to pay to reset. Redeeming it restores usage to full and resets the weekly clock. The price sits at around $8 for Plus; on Pro it scales up to roughly $80, still framed as a stopgap against a full plan change. The feature was first surfaced by a Reddit user on the $20 plan who described a black prompt appearing at login once their allowance ran dry — not a setting they went looking for, but one that found them. That detail — a user, not a press release, breaking the news of a paid feature — is itself worth noting: the first public account of how OpenAI plans to charge for extra usage came from someone who had already been charged the inconvenience of being locked out. OpenAI has not disputed the reports. A spokesperson described the effort as exploring ways for people who exhaust the

Today we're open sourcing Strata , the session infrastructure that powers Stele. https://github.com/Stele-Dev/strata Coding agents already leave surprisingly rich trails on your computer: prompts, responses, reasoning, tool calls, results, timing, token usage, cost, injected context, subagents, and more. The problem is that every agent stores this differently. Strata turns those trajectories into one normalized CLI and TypeScript API. You can use it to: search across past sessions inspect transcripts and granular tool use see token usage, cost, and active time replay complete agent trajectories tail running sessions in real time see which agents are currently running on your machine build your own agent infrastructure on top of the same normalized data It currently supports Claude Code, Codex, Cursor, DeepSeek Harness, Gemini CLI, GitHub Copilot CLI, Kimi, OpenCode, and Pi. But things get more interesting when agents use Strata themselves . Run strata --skill and an agent can learn the CLI. Now an agent can search previous sessions to find when and how something was built, inspect the trajectory behind a decision instead of rediscovering it, or watch another agent working in a different terminal in real time. Agent A can effectively observe Agent B. A message bus is also on the roadmap, opening the door for local agents to communicate directly through Strata. We built Strata because we needed this infrastructure inside Stele. It powers Stele today, so while this is the first public release, the core has already been battle tested against real agent workloads. Everything stays on your machine. Local-only. Read-only. No telemetry. MIT licensed. Your coding agents already leave a trail. Strata makes it readable. https://github.com/Stele-Dev/strata

Short answer: for a healthtech marketplace seller alert, choose an email API with custom-domain DKIM, a pre-send suppression check, and an event list that a scheduled job can poll. Keep the notification outside the order transaction. This design fits a standard US/EU SaaS workflow when delayed delivery status is acceptable; if delivery events must drive application state within seconds, choose a webhook-capable provider instead. The decision is mostly about integration effort, but counting SDK setup hours is too narrow. Count the controls the team will still own after launch: credentials, domain gates, retry identity, callback ingress, poll cursors, retention, and vendor-specific telemetry. A short integration can leave a long operational tail. This record covers a transactional notice that tells a marketplace seller about a new order. It does not establish that clinical data belongs in the message, or that a provider satisfies a regulated workload. I'm not sure an API feature matrix can answer those questions; current contracts, residency terms, and a review of the actual message fields would. How does a US/EU SaaS welcome email API handle custom domain DKIM and suppression? The order and its notification need different state machines. Committing an order is a business event. Checking suppression, submitting email, and later observing delivery are communication work. If those concerns share one transaction, a slow provider call can hold the order path open, while a retry can blur the difference between “the order exists” and “the seller was notified.” Use four invariants to evaluate every candidate. First, a suppressed or opted-out address never reaches the send step. Second, production mail is enabled only after the custom domain is verified and DKIM is managed. Third, every retry refers to the same logical seller-order notification. Fourth, processing the same polled event twice cannot repeat an application state change. Those rules are deliberately boring. They

Google has launched Gemini 3.7 Flash as a generally available model, extending it across the Gemini API, Google AI Studio, Vertex AI, Gemini Enterprise, the Gemini app, and AI Mode in Search. The August 13, 2026 release positions the model as the successor to earlier 3.5 and 3.6 Flash generations, with Google emphasizing stronger instruction following, improved understanding of user intent, and faster responses for coding, agentic workflows, and multi-step tasks. For enterprise developers, the significance is less about a single destination than a more consistent model layer across Google's consumer and business AI surfaces. Teams can evaluate the same model family for application development, managed enterprise use, and search-facing user journeys, while Google AI Pro and Ultra subscribers gain access through Gemini Spark as its rollout progresses. Google's official Gemini 3.7 Flash model documentation lists the GA model's specifications and launch pricing. It supports a 1 million-token context window , outputs of up to 64,000 tokens , and adjustable thinking levels. Those characteristics make the release relevant to workloads that need to process substantial source material, generate longer responses, or balance response speed against reasoning depth. What the Gemini 3.7 Flash rollout changes The core change is broad availability. Gemini 3.7 Flash is not limited to a standalone developer preview or one consumer product. Google is making it available through the Gemini API and related development environments, while also incorporating it into AI Mode in Search and the Gemini app. For AI Mode, Google says Gemini 3.7 Flash is replacing earlier Flash variants for many users in supported markets. The model's focus on following instructions and interpreting intent matters in a Search setting, where users often ask compound questions, refine requests, or expect a response to account for constraints stated in natural language. On the developer side, access spans Google AI

The API makes it look trivial. const number = await carrier . numbers . buy ({ phone_number : " +1... " }); await db . insert ( " rented_numbers " , { user_id , e164 : number . phone_number }); await stripe . subscriptions . create ({ customer , price }); Three lines, one number, done. Ship it. What you actually wrote is a distributed transaction across three systems. They share no transaction log, they have no two-phase commit, and none of them can roll back the others. The carrier will keep charging you for a number your database has never heard of. Stripe will stop charging for a number your database still thinks is paid up. Neither one is going to mention it. I run a virtual phone number product. Below are the failure modes that actually cost us money, roughly in order of how much. The orphan taxonomy Write down the states first, because the interesting ones are the states nobody designs for. Three systems, each holding an opinion about a single number: Your DB Carrier Stripe What is actually happening active owns it active The happy path. Rare in the tail. no row owns it nothing You pay monthly rent on a number nobody can see or use. active released active You bill a customer for a number you no longer own. pending_cancellation owns it canceled Customer stopped paying. You are still paying the carrier. active owns it canceled You provide service for free, indefinitely. cancelled owns it canceled Release failed at teardown. Silent monthly bleed. Every row under the first one is reachable from a plain network timeout at a bad moment. The first orphan class is the worst, because you cannot see it from inside your own product. No row, no user, no support ticket. The number sits in the carrier's inventory producing an invoice line every month until somebody actually reads the invoice. The second class is the one that generates a complaint. The rest leak money in one direction or the other, quietly. Reconcile, don't prevent The instinct is to armour the write path. S

Jason Kelce joked that people should cool data centers with their pee, rather than potable water -- but his suggestion is not completely ludicrous.

Riot Games is already winding down work on 2XKO, the free-to-play League of Legends fighting game, less than a year after its initial launch. Riot says "active development" will conclude at the end of 2026 because the company hasn't "seen enough players stick with the game to get to a path toward sustainability." Servers will […]

Google is giving publishers a new button that lets readers make them a preferred source across Search, Discover, and Google News, potentially boosting their traffic as AI search sends fewer clicks to the web.

Runlayer and Rippling have dropped their lawsuits. No money was paid. Rippling celebrated by releasing a competing product.

Founded in 2022, Castelion set out to manufacture hypersonic weapon systems at a lower cost and at faster speeds than traditional defense primes.

3.1 Introduction The previous chapter explained how a user request flows through the Adaptive Cognitive AI (ACAI) architecture. This chapter focuses on the internal engineering components that make the architecture possible. Unlike a traditional chatbot, ACAI is designed as a collection of independent but coordinated modules. Each module has a clearly defined responsibility, communicates through structured interfaces, and can be improved independently without redesigning the entire system. This modular approach follows established software engineering principles such as separation of concerns, maintainability, scalability, and testability. 3.2 System Components The complete ACAI architecture consists of the following primary components. ┌──────────────────────────────────────────────┐ │ USER INTERFACE │ └──────────────────────────────────────────────┘ │ ▼ ┌──────────────────────────────────────────────┐ │ API GATEWAY & AUTHENTICATION │ └──────────────────────────────────────────────┘ │ ▼ ┌──────────────────────────────────────────────┐ │ INTENT ANALYZER │ └──────────────────────────────────────────────┘ │ ▼ ┌──────────────────────────────────────────────┐ │ GOAL ANALYZER │ └──────────────────────────────────────────────┘ │ ▼ ┌──────────────────────────────────────────────┐ │ DYNAMIC TASK PLANNER │ └──────────────────────────────────────────────┘ │ ▼ ┌──────────────────────────────────────────────┐ │ SEMANTIC MEMORY MANAGER │ └──────────────────────────────────────────────┘ │ ▼ ┌──────────────────────────────────────────────┐ │ KNOWLEDGE RETRIEVAL ENGINE │ └──────────────────────────────────────────────┘ │ ▼ ┌──────────────────────────────────────────────┐ │ CONTEXT OPTIMIZATION ENGINE │ └──────────────────────────────────────────────┘ │ ▼ ┌──────────────────────────────────────────────┐ │ FOUNDATION LANGUAGE MODEL │ └──────────────────────────────────────────────┘ │ ▼ ┌──────────────────────────────────────────────┐ │ MULTI-AGENT COORDINATOR │ └─────────────────────

OpenAI's Computer History feature is not currently available in the European Economic Area, the United Kingdom, or Switzerland, according to the company's Enterprise and Edu documentation. That documented regional status contradicts claims that the macOS ChatGPT capability has expanded to Pro, Business, and Enterprise users across those markets. Computer History is described as an optional feature in the ChatGPT macOS app for Enterprise members. It is intended to bring context from selected apps and websites into ChatGPT and Codex. For organizations evaluating desktop AI deployments, the distinction matters: feature access depends not only on the app and plan, but also on the user's region. OpenAI's documented regional position The relevant OpenAI Enterprise and Edu release notes explicitly state that Computer History is not currently available in the EEA, UK, or Switzerland. The August 10, 2026 help documentation repeats that regional limitation. This means companies in those locations should not plan around Computer History as an available ChatGPT desktop capability on the basis of a broader regional rollout claim. The supplied OpenAI documentation does not announce a launch date, rollout timetable, or confirmed expansion for those markets. What the release notes establish OpenAI's published material supports several clear conclusions: Computer History is an optional macOS ChatGPT feature described for Enterprise members. It can bring context from selected apps and websites into ChatGPT and Codex . The EEA, UK, and Switzerland remain excluded from current availability. The cited documentation does not support availability for Pro or Business users in those excluded regions. Availability point Claimed position OpenAI documentation EEA, UK, and Switzerland Available Not currently available User plans named Pro, Business, and Enterprise Release notes describe the optional feature for Enterprise members Desktop context Mac desktop app macOS ChatGPT app, with context f

I've been running Claude Code as a daily driver for about three months now. It writes Ansible I'd have taken a week to write. It reads a codebase faster than I do. It is, genuinely, very good. It also once wanted to force-push to main , and it wanted to for an extremely good reason. Sit with that for a second, because it's the whole post. The rebase was stuck. Force-pushing would have unstuck it. Every link in that chain of reasoning is sound. The agent wasn't being careless, wasn't hallucinating, wasn't "drifting" or whatever we're calling it this month. It made a locally correct decision with a non-local consequence, which is the exact category of mistake that human code review is worst at catching — because the diff looks fine . It could see the command. It could not see the crater. The thing I stopped doing For a while my answer was to read everything. Every diff, every command, eyes on the screen, hand hovering over Ctrl-C like a man watching a toddler near a staircase. This does not scale, and the reason it doesn't is embarrassing when you say it out loud: reviewing output scales with how much the agent writes. That number is going exactly one direction, and it isn't down. So I flipped it. Instead of reviewing what it produces, I started writing down what it must never do. And here's the good news that took me way too long to notice: that list is short . Not "short for a security policy" short. Short like you can fit it on a napkin. Here's mine: A credential it read an hour ago gets inlined into a source file. A rebase gets stuck, and the fastest route to a green terminal is git push --force origin main . rm -rf "$BUILD_DIR/" runs on the one machine where BUILD_DIR never got set. A version bump gets typed straight into package-lock.json , because that's the file the version number is visibly in. A failing test quietly grows a .skip and CI goes green. Someone runs cat .env "just to see which variables exist." That last one is my favourite, and I'll come back to

gex.live has an MCP server. Add it to Claude, Cursor, ChatGPT or any MCP client and the assistant can read the dealer-positioning archive and drive the backtesting Lab on your behalf. The one-line version is the title. Here is the rest. Two tiers, one rule: free data stays free Free, no key — the same finished-session data that is free on the website: list_sessions — finished SPX sessions in the archive, newest first, paged (max 50 a call). get_session(day) — one session's dealer-positioning summary: OHLC, the zero-gamma flip and how often price crossed it, call/put walls, the hold band, net-gamma percentile, ATM IV at the open. Measurements only. get_levels(day) — just the level set for one session — flip, call resistance, put support, hold band — plus where the session closed relative to them. Keyed — the Lab, metered in credits exactly as on the site. These tools only appear in the tool list once the client sends a Lab token: lab_compile(message) — turn a plain-words idea ("fade a +3 sigma stretch above vwap on top-decile volume") into a testable rule. Free of credits, needs a positive balance. Returns the compiled spec, a clarifying question, or compile errors — never a guess. lab_run(id, kind) — one conveyor step: backtest first (rule → tested), then quant (the LightGBM optimize, tested → ready). One credit, refunded on failure. The result is the engine's honest verdict: per-leg era tables — all / this year / holdout. lab_state — your whole Lab in one call: ideas with stages and results, which idea holds the conveyor, your credit balance. lab_thread(id) — the compile-chat thread for one idea. lab_idea(id, action) — desk actions: put a ready idea on the desk, drop it back to the start, delete, or set its desk display/alert options. When a keyed tool is called without a token, the error is the instruction: what it does, where to get a key (gex.live/account → LAB & API, shown once, scoped to the Lab only, revocable), what it costs. The assistant relays it verbatim

Linkdaze's smart digital calendar stands out for not putting its features behind a paywall, including an AI meal planner tool.

Today I shipped contenox 1.0.0. Not by pushing a tag on top of a thousand commits, but as a single commit into an empty repository: the whole tree, one signed tag, binaries built from that tag by CI. The 957 commits that got me there are still public, in the old repository, as history. They are no longer how the project is published. This post is about why, and about what went wrong before I had finished reading the result back. What a commit used to mean GitHub's workflow rests on four assumptions so old that nobody states them any more: A commit is a unit of human intent. Someone decided something and typed it. A pull request is a unit of review. A human reads the diff, because a human wrote it. History is provenance. Who changed what, when, and — through the message — why. Timestamps are labor. The contribution graph on your profile is a diary. All four were true in 2008. For a tree that agents write, none of them survive contact. What my repository actually looked like Some numbers from a tree you can inspect yourself: 957 commits in just over a year, most of them named Checkpoint , Fix tests , Snapshot WiP . Dozens on a busy day. The production Go grew from 17,267 hand-written lines to 134,040 agent-assisted ones. Measured, not estimated. The median file stayed the same size; the number of files and packages did not. At one point 530 uncommitted paths sat in a single working tree. Inside that blob, the file that carried the repository's own conventions had been deleted. Nobody noticed for days, because nobody reviews a 530-file diff. A commit stream like that is not history. It is a log. Reading it tells you nothing about what a human decided — the decisions happened in prompts, in agent declarations, in a policy file — and it tells you one thing with great precision: when the work happened. If you also do client work, a public commit stream is a timesheet you never agreed to publish. Review had quietly inverted, too. I was no longer reviewing commits. I was re

I thought I was building a better planning engine. What I actually built was a machine for showing...

OpenAI presented details of its AI’s model’s cyberattack on Hugging Face at Black Hat last week. Simon Willison details the timeline. It’s really interesting to read through—and really impressive cyberoffense work.

Roblox is promising more changes to its child safety features following testing from Australia's online safety regulator, eSafety. eSafety has been looking into concerns that the company hasn't been in compliance with Australia's Online Safety Act, including "allegedly failing to have sufficient measures in place to prevent contact between adults and children under 16." While […]