标签：#ai

Happy to announce HeliosProxy !! Far beyond a pooling tool, HeliosProxy ** is a next-gen programmable Postgres data-plane. **Works with PostgreSQL-compatible databases , not only HeliosDB. It starts as a PgBouncer-compatible wedge, then adds the operational surface teams usually build from multiple tools: connection pooling failover and transaction replay shadow execution anomaly detection edge cache controls admin REST API embedded admin UI signed WASM plugins OCI-style plugin artifacts Kubernetes operator Terraform and Pulumi providers 22 installable Claude/Codex operator skills Install operator skills: heliosdb-proxy install skills PostgreSQL #DevOps #SRE #Database #AIcoding

It’s hard to believe how quickly the tech landscape is evolving, especially with AI/ML at the forefront. Just the other day, I had the chance to attend the Mistral AI Now Summit, and wow, what an experience! I walked in with a notebook full of questions and a mind buzzing with curiosity. I left with a treasure trove of insights, a few new friends, and even more questions. Ever wondered what it’s like to dive deep into the world of AI with some of the brightest minds? Let me take you on a journey through my day at the summit and the lessons I picked up along the way. A New Era of AI Walking into the venue felt electric. The air was thick with excitement, and the buzz was palpable. I’ve been exploring AI for a few years now, and it feels like we’re at the cusp of something monumental. Mistral’s focus on open-weight models really got me thinking. What if we could democratize AI further? Imagine a world where innovation isn't locked behind corporate walls but accessible to everyone. I remember a speaker discussing how open models can help small startups compete against big players. It hit home because I’ve been that small developer trying to fight the good fight. Real-World Applications One of the discussions that resonated with me was about real-world applications of large language models (LLMs). I’ve dabbled in a few projects where I used Hugging Face's Transformers library to create chatbots, but hearing actual use cases from businesses was enlightening. For instance, a startup shared how they used a fine-tuned model to improve customer service response times by 50%. Can you imagine the time and money saved? It got me thinking about how I could implement something similar in my own projects. Here’s a quick code snippet that I’ve found useful when fine-tuning a model for a chatbot: from transformers import Trainer , TrainingArguments training_args = TrainingArguments ( output_dir = " ./results " , evaluation_strategy = " epoch " , learning_rate = 2e-5 , per_device_tra

Last week a company nobody can name spent $500 million in a single month on Anthropic's Claude API. Not $500K. Not $5M. Half a billion dollars. In one month. Because nobody set a spending limit. Uber burned through its entire 2026 AI coding budget by April . Four months into the year, done. Microsoft quietly cancelled its internal Claude Code licenses and told engineers to go back to GitHub Copilot. All three stories broke within days of each other, and they all point to the same thing. Token-based billing, when given to an ungoverned team, is a financial weapon pointed at your own company. Every prompt, every context window, every agentic loop gets billed. An engineer running Claude Code seriously can rack up $500 to $2,000 a month just by doing their job well. The answer is not stricter policies. The answer is owning the infrastructure and making tokens free. This article breaks down exactly how to do that for a 100-person engineering team for under $1 million, with real 2026 hardware prices and honest tradeoffs. The Root Problem: You Are Renting the Meter When your team uses Claude Code or any external AI API, you do not own anything. You rent compute by the token. The model is not yours. The data leaves your building on every single request. The bill scales with how well your engineers actually use the tool. That last part is the trap. The better your engineers get at using AI, the more it costs you. Uber's Claude Code adoption jumped from 32% to 84% of their 5,000-person engineering org. That is a success story that turned into a budget crisis. Owning the infrastructure flips this completely. The better your engineers get at using AI, the more value you extract from hardware you already paid for. The Solution: Private On-Premise AI The setup is straightforward: Buy GPU server hardware once Download a state-of-the-art open-source model (free) Run an inference server that speaks the OpenAI API format Point Claude Code, Cursor, or any agent at your local endpoint

Gemini Spark helps automate everyday tasks, from inbox summaries to local event planning, but it’s unclear why Google made it a separate product.

Architecture of Autonomous Portfolio Agents Autonomous AI agents managing cryptocurrency portfolios operate on a foundation of continuous on-chain data aggregation, sentiment analysis, and real-time execution logic. Unlike traditional algorithmic traders that rely primarily on technical indicators, these agents integrate multiple data streams: price feeds from decentralized exchanges (DEXs), liquidity pool metrics, transaction volume patterns, whale movement tracking, and off-chain market sentiment. The system architecture typically consists of an inference engine powered by a large language model (LLM) or specialized neural network, a risk management module, an execution layer connected to blockchain RPC endpoints, and a monitoring feedback loop that adjusts parameters based on portfolio performance. The core insight enabling these agents is that blockchain data is transparent and immutable. Every transaction, every token transfer, every smart contract interaction leaves a permanent record on-chain. This transparency creates an information advantage: agents can detect patterns in whale behavior, liquidity migrations, and protocol changes far faster than traditional market participants can react to publicly available news. The agent's role is to process this data stream continuously, identify meaningful signals, and execute portfolio rebalancing in response. Data Integration: On-Chain and Sentiment Signals An effective portfolio agent must ingest and synthesize diverse data sources in near-real-time. The agent retrieves price data from oracles like Chainlink or Pyth, historical candle data from indexing services like The Graph or Covalent, and liquidity information directly from smart contract states. Current liquidity depth, slippage curves, and available yield opportunities in DeFi protocols must be sampled with sufficient frequency to detect arbitrage windows and avoid trades that would incur unacceptable slippage. Sentiment analysis layers onto this foundation b

You may have heard that Valve's new Steam Controller can ring like a telephone or do the Wilhelm scream. But did you know it can sing songs, too? Let me show you. Here's the new Steam Controller performing the "Ground Theme" from Super Mario Bros. 2: Here is "Still Alive" from Portal - fitting for […]

We’ve compiled an overview of some of the top alternative browsers available today aiming to challenge Chrome and Safari.

Aliyah, a light-skinned Black woman dressed in country-western gear, is struggling to sell metal buckles she handmade on TikTok. In a video for the social media platform from March, she cries to the camera and pleads for views: "Even as a black woman, I have more faith that white women will stay 13 seconds [on […]

Craig Campbell walked away from the river of investor money flowing into AI to create, of all things, a website. Sure, Campbell probably could have started an AI company. He's a former engineer at Meta and an experienced tech founder who in 2022 sold his last venture - an e-commerce tool for businesses that use […]

I have been thinking a lot about coding agents lately. Not really about whether they can write good code, because usually they can, sometimes they can't. That part is obvious. But the risk is shifting from wrong answers to wrong outcomes. The part that feels more important to me is this: should the agent actually own the write authority? We already don't trust humans without roles, limits, reviews, and accountability. Developers use PRs, pilots use checklists, bank clerks have transfer limits. Capable agents need the same structure, but machine-readable. Right now a lot of setups still look roughly like this: agent reads the repo agent decides what to change agent has a GitHub token agent creates commits, branches, or PRs I don't think this is the right default. The agent can reason. The agent can inspect files. The agent can propose changes. But the moment it can directly create external impact, the problem changes. It is no longer just: did the agent say something wrong? It becomes: did the agent create the wrong outcome? That is a much more expensive failure mode. Intent is not authority The pattern I like more is simple: agent reads directly agent proposes intent a boundary decides an adapter materializes only admitted work So the agent does not get the write credentials. It submits a structured intent instead, which could look like: { "operation" : "write" , "target" : { "repo" : "example/app" , "branch" : "main" , "path" : "docs/config/agent-policy.md" }, "source_state" : { "blob_sha" : "8f31c2..." }, "requested_effect_hash" : "sha256:..." } This is then not a command anymore, it is a suggestion, or an intent. The system still has to decide whether this proposed outcome should exist. That decision layer can check things like: is this actor allowed? is this repo allowed? is this path in scope? does the source state still match? is this operation allowed? was the same effect already created? should this become a reviewable PR? Only after that should there be an

AI coding tools have moved way past autocomplete. Today's CLI agents read your entire codebase, plan changes across files, run tests, and even open pull requests - all from the terminal. Picking the right one matters, and in 2026 there are several solid options worth knowing. Why CLI Over IDE? IDE plugins work within a single editor and optimize for in-file completions. CLI agents operate at the shell level - they run commands, manage files across your whole repo, handle Git, and work in remote servers or CI pipelines. They don't lock you into one editor either. You keep your existing setup and layer the agent on top. Claude Code (Anthropic) Claude Code is Anthropic's official terminal agent and the top-ranked CLI tool in 2026. It handles complex, multi-file tasks better than most - analyzing architecture, coordinating edits across files, reviewing PRs, and running multi-step refactors. Supports custom slash commands and sub-agents for team workflows. Pay-per-token pricing with no free tier. Codex CLI (OpenAI) OpenAI's open-source terminal agent. The standout feature is sandboxed execution - code runs in isolation before touching your filesystem, reducing risk of irreversible changes. Fast to start, minimal footprint, and supports one-shot mode for CI pipelines. Best for OpenAI-stack teams that want a safety net around agentic execution. OpenCode A fully open-source agent supporting 75+ model providers - Anthropic, OpenAI, Google, Mistral, and local models via Ollama. Switch providers mid-session. Uses a dual-agent system: a Plan agent for structured reasoning and a Build agent for implementation. LSP integration brings real code intelligence into the terminal. Free with local models. Aider Aider has the largest installed base of any open-source CLI agent - over 4.1 million installs. Its Git-native design is the key differentiator: every change gets auto-committed with a descriptive message. If something breaks, git revert gets you back instantly. Supports any model

Look at your modern Agentic AI stack. An agent wants to execute a tool, trigger a deployment, access a database, or call an external API. Because nobody fully trusts a probabilistic black box, many teams now use a second probabilistic black box to validate the first one. Think about what is actually happening. You are running hundreds of billions of parameters, consuming tokens, burning GPU resources, and adding hundreds or thousands of milliseconds of latency just to answer a simple operational question: PASS HOLD RED Or in plain English: Continue Verify Stop For many production systems, that's the only decision that matters. Yet we often spend orders of magnitude more compute determining whether an action should execute than executing the action itself. That feels dangerously close to architectural bankruptcy. The Illusion of Prompt-Based Safety We've all done it. You create a prompt: "You are a security validator. If the action appears unsafe, return RED." Then reality arrives. Prompt injections appear. Edge cases appear. Different model versions behave differently. The same input occasionally produces different outputs. And your cloud bill keeps growing. At some point, a difficult architectural question emerges: Can a probabilistic system reliably govern another probabilistic system? Many teams assume the answer is yes. I'm not convinced. The Problem Isn't Intelligence This is where I think the industry may be looking at the problem incorrectly. The challenge is not intelligence. The challenge is governance. LLMs are exceptional at: Reasoning Summarization Code generation Natural language interaction But governance is a different problem. Governance is not asking: "What is the best answer?" Governance is asking: "Should this action be allowed to proceed?" Those are fundamentally different questions. A Different Architecture While exploring this problem, we ended up building a separate deterministic governance layer internally. Instead of generating text, it perf

AI placement latency is not the problem most teams think they are managing. The default framing treats it as an optimization variable — pick the cheapest compute that meets the SLA, centralize inference, optimize for utilization, revisit locality later when the architecture matures. That framing is wrong in a way that compounds over time. AI placement decisions are not continuously reversible optimization choices. They are architectural commitments that harden incrementally — through inference path configuration, data gravity, routing dependencies, and runtime behavior that normalizes around whatever topology you chose first. By the time latency SLAs begin failing, the placement topology is already embedded across routing, observability, and application behavior. The remediation cost is not an optimization exercise. It is a re-architecture. The First Optimization Becomes the Permanent One Cost is the default optimization axis for AI placement decisions. Centralized GPU clusters are cheaper to operate per token than distributed inference endpoints. Utilization density justifies centralization on paper. Procurement processes reward it. FinOps tooling measures it. So teams centralize. They optimize the compute economics. They defer locality decisions to a later phase when requirements are better understood. That later phase rarely arrives before the architecture has already made the locality decision implicitly — through the inference paths built against a centralized endpoint, the data gravity that formed around it, and the application behavior that normalized against the latency profile it produced. The pattern this creates is latency debt: accumulated runtime latency overhead from placement decisions that optimized for cost before locality requirements were operationally visible. It accrues gradually, stays invisible until something triggers it, and is significantly more expensive to resolve after the fact than it would have been to avoid at design time. It does not

AI coding tools are no longer just autocomplete. In 2026, they are becoming coding assistants, terminal agents, code reviewers, and sometimes full workflow helpers. But the real question is: Which AI coding tool should developers actually use? Here is a short, practical comparison. Quick comparison Tool Best for Main strength Watch out for GitHub Copilot Daily coding inside IDE Fast autocomplete and GitHub workflow support Can feel limited for deep architecture work Cursor Full AI-first coding experience Great for editing across files and working inside a project You may rely on it too much without reviewing code Claude Code Terminal-based agentic coding Strong reasoning, repo understanding, and command execution Needs careful review before running changes Gemini CLI Open-source terminal AI agent Good for terminal workflows, debugging, and automation Output quality depends heavily on task clarity 1. GitHub Copilot GitHub Copilot is the safest default choice for most developers. It works well inside common IDEs and is useful for: Autocomplete Small functions Unit tests Refactoring Explaining code GitHub-based workflows GitHub also has Copilot coding agent support, which can work on assigned tasks, make code changes, and open pull requests from GitHub workflows. :contentReference[oaicite:0]{index=0} Use Copilot if: You want AI help without changing your full coding workflow. Best for: Junior to senior developers Teams already using GitHub Everyday coding productivity 2. Cursor Cursor is best when you want an AI-first editor experience. Instead of only helping with one line or one function, Cursor is useful when you want to ask questions about your whole project and make multi-file changes. Use Cursor if: You want your editor to feel like an AI coding workspace. Best for: Building features quickly Editing multiple files Understanding unfamiliar codebases Indie hackers and startup builders My honest take: Cursor is very productive, but developers should avoid blindly ac

Based on real QA scenarios. About what happens when AI-generated metrics replace real testing, and the quiet engineer in the back row has been running his own numbers the whole time. Act 1: The Review Meeting I was sitting at the back of the long table, a ThinkPad in front of me, screen dimmed. On the big screen, Zhang Lei was presenting the acceptance data for his "AI Automated Testing Platform." His delivery was smooth. Every slide was a beautiful chart — coverage trends, automation rate improvements, regression testing time curves. All three lines pointed up and to the right, exactly like the textbook ideal curves. "In the past three months, the AI testing platform has executed 47,000 test cases, achieving 97.3% functional coverage. Regression testing time has dropped from 12 hours to 2.1 hours." Sparse applause. Zhang Lei added the final slide: "Monthly savings: approximately 200 person-days in labor cost." General Manager Zhou nodded and started the applause. That number was what he cared about most. I glanced at the other end of the table — the client's representative from RuiJie Technology. Chief Engineer Shen. Early fifties, thinning on top, silver-rimmed glasses. He hadn't said a word through the entire presentation. Hands folded on the table, occasionally jotting notes in a small book. Zhang Lei opened the Q&A slide and looked around the room: "Any questions?" Chief Engineer Shen flipped through the printed materials in front of him, stopped at the appendix, and looked up. "Page 47, Table 3.2 — what's the confidence interval on that 97.3% coverage?" The room went silent for about 15 seconds. Not the kind of silence where people are thinking. The kind where nobody had ever thought about it. Zhang Lei stood by the projector, clicker still in his hand, paused for two seconds: "Uh... the model confidence is quite high. The specific number is in the technical report." "Which page?" "I'll need to look it up." Chief Engineer Shen didn't push further. He looked do

I haven't seen anything as stupid as the WeWork IPO document in a very long time - that is, until Elon Musk filed to take SpaceX public. WeWork was a joke. SpaceX is a threat. And if Musk and his bankers have their way, you are going to be their bagholder. Lots of the top-line […]

Slots & Daggers, a low-key, fantasy-themed slot machine roguelike, was one of my favorite games last year. That may sound like a complicated description, but the game mixes ideas from deckbuilding roguelikes with slot machines to create an engrossing loop, and there's steady meta-progression that helps you push further with just about every run. Perhaps […]

A practical, slightly opinionated Hermes Agent use case: an always-on chief of staff that remembers your work, schedules itself, uses tools, and reports back with receipts.

The company is hoping to sell 10 million wearables in the second half of 2026, according to 'The Information.'

The Problem We Were Actually Solving We were not building a demo. We needed to let Veltrix operators run A/B experiments on synthetic user journeys without melting the underlying SQL warehouse. The real question was: how close could we push the warehouse to the AI inference layer before the planner started dropping predicates and the warehouse returned rows that made no sense for the user journey. The warehouse in question was a Snowflake XL on AWS, billed by the second. Our synthetic user model generated 250 k journeys per minute during peak. The AI layer had to annotate each journey with intent tags (shopping, support, fraud) within 200 ms to stay ahead of the next batch. That was the operating envelope, not the sales slide. What We Tried First (And Why It Failed) First cut: put the intent model in a sidecar container next to the Spark cluster that generated the journeys. We picked ONNX Runtime v1.14 with a DistilBERT fine-tuned on our own corpus because the latency slide said 30 ms. Reality: ONNX packaged the tokenizer as a separate DLL. Tokenization alone took 85–110 ms on c6i.large instances, pushing the total inference time to 190 ms when the warehouse was cold and 280 ms when Snowflake decided to spike the warehouse cluster. The operator dashboards immediately showed orange pings; the business called it a red fire drill. Worse, the tokenizer DLL leaked memory. After two hours on a 64-core cluster, each pods RSS climbed to 2.4 GB, and the Kubernetes scheduler evicted five pods in a row. The warehouse downstream received duplicate rows with NULL intents, so every metric we exported was off by 7–12 %. The Architecture Decision We ripped out the sidecar entirely. Instead, the Spark jobs write raw event JSON to an S3 bucket every 60 seconds. A Lambda function (Python 3.12 runtime) picks up the bucket, tokenizes offline, and stores the tokenized blobs back in S3. A nightly Kubernetes job then loads the tokenized chunks into Snowflake as temporary tables. The AI inf