标签：#AI

AI coding agents are useful, but team collaboration around them can become messy very quickly. A common shortcut is to share an account, API key, or long-lived access token so another teammate can run a task. It may feel convenient, but it creates avoidable security, ownership, and review problems. A better approach is to separate the task from the account that executes it. The person requesting the work prepares a complete, portable task. The person running it uses their own authorized AI-agent subscription and returns the result with evidence. Here is a practical way to structure that workflow. Why shared AI accounts create problems When several people use the same AI account, it becomes difficult to answer basic operational questions: Who initiated a specific action? Which person approved the resulting changes? What project context was exposed? Who is responsible for reviewing the output? What happens when a teammate changes roles or leaves? Shared credentials also tend to spread. A password may end up in a private message, a token may be copied into a local configuration file, or a browser session may remain active on an unmanaged device. Even when everyone involved is trusted, the process itself is difficult to audit. The goal should not be to share access more efficiently. It should be to share the work without transferring the account. Treat the task as a portable unit A useful AI task should make sense outside the original conversation in which it was created. Someone receiving the task should be able to understand: the desired outcome; the relevant project context; the boundaries of the work; the evidence required for completion; the decisions that still need human review. This turns the request into a portable unit of work rather than a fragment of chat history. For example, instead of writing: Update the import flow. Write something closer to: When a user uploads a CSV containing duplicate email addresses, show a validation summary before importing any re

The European Commission’s 2022 procurement for a participatory foresight study on next-generation online platforms placed platform design and consumer behaviour within a wider policy question: how could the platform economy evolve, and what might those changes mean for European Union policymaking? The work was not a narrow experiment on marketplace user experience. Instead, it was a two-year exercise intended to identify long-term trends across online platforms and assess their policy implications. The Commission published the call, reference CNECT/2022/OP/0049 , in August 2022. Its official announcement of the foresight study on the future of online platforms lists a submission deadline of 22 September 2022 at 16:00 CEST . That makes the procurement a completed historical call, rather than a current tender opportunity. The framing remains relevant because interface design, recommendation systems and other platform choices can influence what people notice, compare and select online. But the Commission’s stated objective was broader than any one marketplace design question. It sought a structured view of the platform economy’s possible future trajectories and the public-policy issues those trajectories could raise. What the 2022 study was designed to examine The Commission described the project as a two-year participatory foresight study . Participatory foresight brings relevant groups into a structured exploration of future developments rather than attempting to predict one fixed outcome. In this case, the study was designed to identify ten topics in collaboration with Commission services, then examine long-term trends and their potential policy relevance. Design’s influence on consumer behaviour was part of the broader theme, not the full scope of the procurement. That distinction matters. A study focused solely on a marketplace interface might measure how a particular ranking, default or layout affects a defined consumer decision. The Commission’s foresight work i

MCP servers give large language models a route to query data sources, call software tools, and trigger actions in connected systems. That capability also changes the security boundary. n8n argues that production deployments need a dedicated MCP control plane to govern which actions an agent can take, under what identity, with which credentials, and with what record of execution. In its July 1, 2026, official guide to MCP server security , n8n describes the control plane as an orchestration layer for MCP activity. Its role is not to make an LLM inherently trustworthy. Instead, it applies operational controls around the model's requests before those requests reach target tools and systems. For enterprises exploring agentic automation, that distinction is central: capable tool use requires enforceable boundaries. What an MCP control plane changes An MCP server defines a surface through which an LLM can access tools and data. In a production setting, simply exposing that surface is not sufficient governance. A control plane adds an execution layer that can scope tool calls, isolate credentials, and log each action. n8n positions itself between the agent and target systems in this model. That intermediary role is intended to keep credentials out of the agent while allowing authorized workflows to access connected services. It also gives organizations a place to apply authorization and retain an audit trail as tool use expands across teams and systems. The shift is from treating an MCP connection as a direct capability grant to treating it as a governed request path. A control plane can make several production controls explicit: Authentication verifies the caller before access is granted. Authorization and tool-call scoping constrain which tools and actions are available for a given context. Credential isolation separates agent activity from the credentials used to reach target systems. Execution logging records actions for auditing and investigation. Least-privilege expo

Most speech-to-text is benchmarked on audio that looks nothing like a WhatsApp voice note. The standard evaluation sets are read speech, broadcast news, or recorded interviews: single speaker, decent microphone, one language, quiet room, speaker aware they are being recorded. A WhatsApp voice note is close to the opposite on every axis. I have spent a while building around this, and the gap turned out to be wider than I expected. Acoustics Phone held at arm's length while walking, in a car, in a kitchen, on a street. Distance-to-mic varies wildly within a single recording , which breaks a lot of assumptions about consistent gain. Then there is the codec. Voice notes are Opus at low bitrate — efficient, but it discards exactly the high-frequency detail that helps disambiguate fricatives. /s/ versus /f/ versus /th/ get genuinely harder, and those distinctions carry real meaning. Register Conversational, not read. False starts, self-corrections, filler, trailing off mid-sentence, and long pauses that are not sentence boundaries — someone thinking, or getting distracted. Punctuation inference is much harder here than on read speech. And punctuation is most of what makes a transcript skimmable rather than a wall of text. A perfectly accurate word sequence with no paragraph breaks is close to useless if the point was to let someone read it faster than listening. Language This is the one that surprised me most. Voice notes are heavily code-switched. People drop English technical terms into Urdu, Hindi, Arabic, Spanish sentences constantly — not as an edge case, as the default register for a huge number of speakers. If you force a single language selection up front, you mangle every mixed utterance. Auto-detection is not a convenience feature in this domain. It is a correctness requirement. Length distribution Most notes are 5–45 seconds. Very little context to work with, and per-request overhead dominates if you architected for long files. Batching strategies that make sen

Liar’s Dice sounds like a perfect game to put onchain. The rules are simple, every move can be verified, and you don’t need a centralized game server deciding who won. There is just one problem. Blockchains are public. Liar’s Dice only works if your dice are private. If I simply stored every roll inside a normal smart contract, anyone could inspect the state and know exactly what everyone was holding. At that point, there is no bluffing. You would basically be playing poker with everyone's cards face up. So I built FHE Liar’s Dice , a decentralized version of the game where your dice remain encrypted while the game is being played. Not hidden behind a backend. Not stored privately in some database. Encrypted onchain. And the interesting part is that the smart contract can still use those encrypted dice to determine whether you are lying. The problem with putting hidden-information games onchain Most blockchain games actually benefit from transparency. If you're building something like chess, every player is supposed to know the complete state of the board. Liar’s Dice is different. Each player starts with five dice that only they should be able to see. Players then make public claims about the combined dice across the entire table. You might say: There are six 4s on the table. The next player has two choices. Raise the bid. Or call your bluff. The entire game comes from the fact that nobody knows exactly what everyone else is holding. But a traditional smart contract has the opposite property. Its state is transparent. Even if the frontend refuses to display your dice, someone can simply inspect the contract, query the state, watch events, or build their own interface. Hiding something in the UI isn't privacy. I needed the actual game state itself to remain secret. FHE turned out to be a very good fit for the game I built the game using Fhenix CoFHE . Fully Homomorphic Encryption is interesting because it allows computation to happen directly over encrypted values.

Flock’s surveillance cameras have already sparked outrage. WIRED reconstructed its next-generation AI system, already in use by some police, to confirm it goes much further than tracking license plates.

Amazon Web Services has extended Amazon Bedrock AgentCore with runtime instances, a new compute option that gives AI agents persistent infrastructure purpose-built for complex long-running workflows and multi-agent coordination. By Matt Saunders

ByteDance and Tencent have received 10,000 H200 chips each, the Financial Times says, and other Chinese companies could follow.

Preparing for a Python developer interview often starts with coding problems. You practice arrays, strings, dictionaries, functions, and algorithms. Then you solve a few more problems and feel like you're ready. But an actual Python developer interview can test much more than whether you can write working code. You may need to explain your decisions, debug an unfamiliar piece of code, discuss Python concepts, or describe how you would approach a real development problem. Here are the areas I'd focus on before an interview. 1.Don't Just Solve Python Problems—Explain Them It's possible to solve a coding problem correctly and still struggle in an interview. Interviewers often want to know: Why did you choose this approach? What is the time complexity? What happens with edge cases? Is there another way to solve it ? How would you improve the solution? Try explaining your solution aloud after solving it. If you can't explain why your code works, you probably don't understand the solution as well as you think. 2. Know Python Beyond the Basics Don't stop at syntax. Review concepts such as: Lists, tuples, sets, and dictionaries Mutable vs immutable objects *args and **kwargs Exception handling Iterators and generators Decorators List comprehensions Context managers Object-oriented programming Memory management You don't need to memorize every Python feature. Focus on understanding concepts well enough to explain when and why you'd use them. 3. Practice Debugging Real developers don't spend all day writing code from scratch. A large part of the job involves understanding existing code and fixing problems. Take a small Python program with a bug and practice: Reproducing the problem. Reading the error carefully. Finding the likely cause. Testing your assumption. Fixing the issue. Explaining why it happened. This is also useful interview practice because debugging reveals how you think when the answer isn't immediately obvious. 4.Be Ready for Real-World Questions Depending on t

Can't believe I spent 2 weeks writing this. Last week, I gave a talk at a Cursor community event...

For a healthtech verification link, the usual SendGrid vs Resend vs Postmark debate starts too late: the best alternative transactional email API is the one that leaves reviewable evidence after delivery. Short answer: choose a transactional email API only after a small evaluation proves API sending, controlled templates, verified-domain operation, suppression handling, and retrievable delivery records; Infrai is a practical option when those basics matter more than SMTP migration or webhook-driven automation, while teams that require either of those should keep a provider that supplies them. That result sounds less exciting than a feature matrix. Good. A verification message is part of an account-control path, so the useful output of a provider experiment isn't a polished welcome email. It's an evidence packet that connects one signup, one approved template revision, one domain configuration, one send request, and one later delivery record without placing health data in the message or logs. My first pass at this decision would be deliberately small: one synthetic recipient, one expiring link, one correlation ID, and no production data. I don't promote the notebook experiment until the evidence can be checked mechanically. The catch is that a provider can pass the send test while failing the operating model because an auditor cannot reconstruct what happened later. Reliability begins with five linked artifacts Start with five claims and demand an artifact for each. The API accepted a send. The rendered body came from the approved template revision. The sending domain was verified and DKIM could be rotated. A suppressed recipient wasn't treated as a normal send. Finally, a delivery record could be pulled into the team's own evidence store. Google also expects senders to authenticate mail, so domain work is part of the experiment rather than a launch-week chore. For a reviewer, those records need to form one understandable chain: the synthetic signup created a correla

TL;DR For marketplace sales calls, use an async job when several documents must become one reviewed set of CRM actions; use an inline request only when one short document can finish inside the caller's latency budget. Preserve one result per input, expose partial progress, and export only records that carry their source ID, outcome, and schema version. Start with this decision table: Pick Use it when Quality and latency consequence Operational burden Inline request One short transcript produces one independent summary Fast feedback, but the request deadline limits retries and review stages Low until traffic spikes or callers retry Bounded parallel calls A small set of independent transcripts can finish separately Lower wall time, with variable completion order The caller owns concurrency, backoff, and reconciliation Durable async job Multiple documents feed one CRM export or need validation More queue latency, but enough room for retries and quality checks Requires job state, idempotency, metrics, and retention rules The important boundary is not "batch or no batch." It is ownership. If the API accepts a collection, the service should own that collection through terminal results and a verifiable export. Don't make a client reconstruct truth from whichever promises happened to resolve. What should a Node.js batch summarization API do with multiple documents? It should turn an admission request into a stable job record, process every document under a declared concurrency limit, and publish an item-level outcome before it declares the job complete. The result model needs at least four identities: job, input document, processing attempt, and export. Without them, a duplicate submission can look like new work, a retry can overwrite useful evidence, and an export can silently omit a failed call. For the marketplace example, imagine that a seller has three calls about the same account: discovery, pricing, and legal review. The desired CRM update is not merely three paragra

🛡️ Arquitectura de Defensa para Agentes de IA: Cómo asegurar tus LLMs contra Prompt Injection, Tool-Poisoning y Fugitividad. El ecosistema actual de agentes autónomos y servidores MCP (Model Context Protocol) es brillante, pero operativamente es una pesadilla de seguridad. Estamos construyendo sistemas que ejecutan código, acceden a bases de datos y toman decisiones críticas basándose en salidas de texto que son intrínsecamente manipulables. Si estás desplegando agentes en producción confiando únicamente en que el modelo "se portará bien" gracias a su System Prompt, estás completamente desprotegido. Para solucionar esto, he desarrollado un framework de defensa en profundidad distribuido en 4 capas críticas. No se trata de teoría académica; son sensores deterministas y dinámicos listos para producción. 🏗️ Las 4 Capas del Ecosistema de Seguridad. Capa 1: Sanitización de Entrada y Control de Estímulos (Ingress). El ataque empieza antes de que el modelo procese el token. Necesitamos interceptar vectores maliciosos tanto en texto como en medios visuales. hermes-shield: Un sanitizador de entrada anti prompt-injection que opera en 5 capas secuenciales para neutralizar instrucciones hostiles ocultas. vision-injection-guard: Un sensor determinista diseñado para procesadores VLM. Detecta texto malicioso inyectado visualmente en imágenes antes de que el modelo de lenguaje lo interprete. corpus-scrub: Herramienta de prevención de fuga de datos. Detecta y redacta de forma automática PII (información personal identificable) y secretos en tus corpus de datos antes de entrenar o ajustar un LLM. Capa 2: Pasarela de Control y Validación Física (Gateway & Sandbox). Una vez que el agente está activo, no puede comunicarse directamente con el exterior sin un proxy que valide sus intenciones. ai-guard-gateway: Una pasarela de seguridad profesional para endpoints expuestos. Implementa Rate Limiting, redacción de PII en tiempo real, detección de inyecciones y políticas OPA (Open Policy Agen

What tok/s really measures, how concurrency changes it, and why a single-user benchmark is not the whole story for local LLM performance. A Few Moments Later… How Fast Is "Fast"? Every interface in the world of local AI eventually shows you that dreaded spinner, and on the wrong setup it sits there long enough that your brain supplies the meme: "A few moments later…" That pause is a number wearing a disguise. Somewhere inside your machine, the model is grinding out tokens — fragments of words — and the only question that matters is how many of them it produces per second. Tokens per second (tok/s) is the universal speedometer of local LLMs, quoted in every benchmark and every GPU review. But it is also one of the most misleading numbers in the field, because the same model can measure 45 tok/s or 793 tok/s depending on how you test it. This guide explains what the number actually means, why it moves so dramatically, and how to read a benchmark without fooling yourself. What a Token Actually Is Before speed makes sense, the unit has to. Models do not read words; they read tokens, which are chunks of text roughly three-quarters of a character on average in English. The word "calculator" might be one token or three, depending on the tokenizer, and this is not idle trivia — it is the reason the same prompt can cost a different amount across providers, as the Token Counter Calculator shows in practice. Because tokens are the unit of both billing and speed, "tokens per second" is the single number that connects all three corners of the local AI decision: how fast the model answers (tok/s), how big the model is (parameters), and what it costs to run (hardware amortized over time). A model doing 50 tok/s reads roughly 100-150 words per second — comfortably faster than you can read. A model stuck at 5 tok/s feels like a slow internet connection in 1998. The Single-User Number Is Not the Whole Story Here is the trap: most consumer benchmarks report tok/s at one user, one requ

There is a small cluster of posts going around right now about auditing your LLM invoice, and about how cost calculators get the numbers wrong. I went to check mine and hit a problem before I got to the arithmetic: my pipeline doesn't produce an invoice, and the plumbing I built two months ago is the reason why. This project has a script, git_commit.py , that turns a staged git diff into a Conventional Commit message. It shells out to the Claude CLI. There is no ANTHROPIC_API_KEY anywhere in the project, on purpose — an early version used urllib against the API directly and broke immediately for anyone running on an OAuth session instead of a raw key, so every AI call in the repo goes through a claude -p subprocess instead. That decision is still right. It also means there is no API key, so there is no per-key usage dashboard, so there is no line item to audit. For several months this script has been making a model call on essentially every commit, and I have never once known what any of them cost. The call site throws the numbers away Here is the actual invocation, trimmed: raw = subprocess . check_output ( [ " claude " , " -p " , " --safe-mode " , SYSTEM + " \n\n " + diff ], text = True , timeout = 20 , env = _claude_subprocess_env (), ) subprocess.check_output returns stdout. With the CLI's default output format, stdout is the commit message string and nothing else. Every number I would want — tokens in, tokens out, dollars — is computed on the other side of that call and then discarded, because I asked for a string and a string is what I got. This is the part I want to flag for anyone wiring up a headless model call the same way. It isn't that the metering is missing. It's that the default output format is lossy in exactly the dimension you'd later want to audit, and you won't discover that by reading your own code, because your own code looks fine. It asks for text, it gets text. The fix is one flag: raw = subprocess . check_output ( [ " claude " , " -p " , " -

I've written before about SMESH, a coordination protocol modelled on mycorrhizal networks — the fungal web that lets trees in a forest warn each other about drought and disease with nothing in charge of the network. Signals diffuse, decay on their own, and get reinforced when independently confirmed. Consensus emerges instead of being orchestrated. That was the idea. This post is about the part where I found out whether it worked. The transport that had never run SMESH has had a QUIC transport in it for a while. Roughly 500 lines: a quinn endpoint that is simultaneously server and client, self-signed certs, length-prefixed bincode frames over unidirectional streams, an accept loop that spawns per-connection and per-stream tasks, connection pooling. Every test passed. The workspace was green. I could point at smesh-runtime/src/transport.rs and say "yes, it does peer-to-peer." Then I grepped for who actually constructed it: $ grep -rn "QuicTransport" --include = '*.rs' . smesh-runtime/src/transport.rs:177:pub struct QuicTransport { smesh-runtime/src/transport.rs:192:impl QuicTransport { smesh-runtime/src/lib.rs:16:pub use transport:: { QuicTransport, ... } ; Its own definition, and a re-export. Nothing else in the workspace had ever instantiated it. No binary opened a socket. SmeshRuntime imported TransportConfig , stored it in a struct field, and never looked at it again. I had a networking layer with tests, docs, and zero executions. Three bugs in the first twenty minutes I wrote an integration test that starts two runtimes, has one dial the other, and asserts a signal crosses. Here is what fell out before it went green. 1. It panicked on the first call. Could not automatically determine the process-level CryptoProvider from Rustls crate features. rustls 0.23 refuses to pick a crypto backend when more than one is compiled in, and quinn pulls in both through its own feature set. Every call to QuicTransport::new would have panicked for anyone, ever. Nobody noticed bec

I spend a lot of time in the AI space -- reading papers, building things, talking to engineers who are actually shipping. And there is a gap between what the demos show and what production systems actually look like that nobody is being fully honest about. So here is my honest take on where things actually are. The Problem With How We Talk About AI Agents Everyone is calling everything an "agent" right now. A function that calls a tool? Agent. A chatbot with memory? Agent. A script with a loop? Agent. This dilution is not just semantic. It is causing real engineering mistakes. When you do not have a precise definition for what you are building, you end up over-engineering simple pipelines and under-engineering genuinely complex ones. I have seen teams spend weeks adding "agentic" orchestration to workflows that would have been fine as a single well-structured prompt. Here is the definition I keep coming back to: an agent is a system that has an objective, not just an instruction. It decides what to do next. It handles failure. It knows when it is done. Everything else is just a fancy function call. 🟢 If your system needs a human to tell it each step, it is not an agent. It is a chat interface. 🔵 If your system can recover from a failed tool call and try a different approach, you are getting somewhere. ✅ If your system can decompose a goal into subtasks and delegate them, that is the real thing. What Is Actually Happening in Production Right Now The honest picture from teams I follow and talk to: Most real agent deployments are narrow. They do one thing well. Customer support triage. Document extraction. Code review on a specific codebase. They are not general-purpose reasoning engines. They are purpose-built pipelines with some intelligence in the decision layer. The teams getting good results are not chasing the latest model release. They are obsessing over: ☑️ Tool design -- what can the agent actually call, and how clean is the interface ☑️ Failure handling -- wh

I Tested 5 AI Engines On My Own Sites. None Agreed. In July I wrote that my open-source...

Choosing the Right GPU for Your Model — A Sizing Method, Not a Guess OK, you're a senior SRE, you've been hearing incessantly about AI models, but aren't quite sure how to determine the correct node size to host your model. - If so ... you're in the right place. Part of a series on running vLLM on AKS. Companion piece: How to avoid flapping . GPU infrastructure setup — coming soon. This piece walks through estimating GPU memory requirements from both a model's parameter count or a concurrent requests requirement. After reading this article you will have enough knowledge to pick a GPU family with confidence. Disclaimer: this process is a rule-of-thumb filter, not a precise calculation — the last step covers how to get exact numbers once the model is actually running. Background: What actually consumes GPU memory AI models live in GPU memory — VRAM — and engines such as vLLM provide novel techniques for managing that memory efficiently [ paper ], but the model isn't the only thing consuming it. Below is a short list of things that consume our precious VRAM: Model weights — the parameters themselves. The big fixed cost: loaded once, never shrinks. KV cache — working memory for in-flight requests. Every token of every active request holds its attention keys/values here. This is the one that determines throughput : more KV cache = more concurrent requests. Everything else — activations (the temporary tensors of a forward pass) plus CUDA/framework overhead. You don't calculate these by hand; vLLM measures activations with a profiling pass at start-up and prints it for our consumption. The sizing question is really: after weights and overhead, how much is left for the KV cache — and is that enough for your traffic? OK, lets get started Step 1 — Choose a model Guidance on which model to choose is outside the bounds of this article. What matters here: once you have a candidate, everything below can be read off its spec sheet — you can then run this method on every model on y

AI Agents Don’t Need More Context. They Need Memory. S6stem S6stem S6stem Follow Aug 17 AI Agents Don’t Need More Context. They Need Memory. # ai # programming # agents # rust 2 reactions 2 comments 4 min read