标签：#AI

Birinci bölümde bir haber sitesinin yayın akışını ajana devrettiğimi yazmıştım. O yazıdan sonra sistemin en kırılgan yerini kurdum: sosyal medyaya konuşan sanal sunucular . Dokuz kategorinin dokuz karakteri var, her biri kendi videosuyla kendi bölümünü tanıtıyor. Bu yazı o hattın kurulum günlüğü. İçinde çalışan kod da var, çöpe giden yedi deneme de. Neden karakter? Statik bir yazı linkini X'e atınca ölçüm net: kart önizlemesi görünür, kimse durmaz. Dikey videoda konuşan bir insan varsa akış duruyor. Elimde gerçek sunucu yok, o yüzden karakterleri üretiyoruz: Elif (bilim, psikoloji), Arda (oyun), Doruk (doğa ve kamp), Dr. Sinan (tıp), Defne (kitap), Süreyya (tarot), Meriç (dünya basını), Elvan (arkeoloji), Duru (güzellik). Kural basit ve sabit: kategori → karakter eşlemesi değişmez. Aynı etiket her zaman aynı yüz ve aynı sesle geliyor. Takipçi ikinci videoda karakteri tanıyor. Üretim hattı şöyle: konu seçimi → yazı yayını → başlangıç karesi (t2i) → konuşma metni (4 kısa cümle) → i2v video (12 sn, ses dahil) → Whisper doğrulama (eşik 0,80) → kafa1milyon.com etiketi (ffmpeg drawtext) → X + Instagram + YouTube kuyruğu Kritik yer dördüncü satır. Onu anlatayım. Telaffuz savaşı: modelin metni "düzeltmesi" Video modeline Türkçe bir cümle verip "bunu oku" dediğinizde, model okumakla kalmıyor. Metni kendi kendine yeniden yazıyor. Bir inek videosu altı kez çöpe gitti. Model "bilim insanları ile birlikte de bilim insanları" diye kelimeyi tekrarladı. Tıp videosunda "insülin" kelimesini "insülün" diye söyledi ve cümleyi kendi kendine "Tip 1 diyabette beta hücreleri..." diye temkinli bilim diline çevirdi. Bir başkasında "eureka" kelimesi "ürika" oldu. Yedi denemeden sonra kural dosyasına şunlar girdi: Konuşma metni en fazla 4 cümle , cümle başına 4-7 kelime. Yabancı kökenli ve teknik kelime yok. "İnsülin" yerine "şekeri ayarlayan hücreler". İddialı cümle yok. Model abartıyı düzeltmeye çalışıp metni bozuyor; cümleyi baştan dürüst kurmak gerekiyor. Prompt'a "do not reword or rephras

Hello! It has been a couple of months since I announced my latest project, Testing Rails from Scratch: A practical, (mostly) out-of-the-box approach to test-driven development in Ruby on Rails . The book is a thought experiment of sorts, as I revisit the default Rails testing stack after years of RSpec. I've been incrementally exploring the defaults and building tests from the foundational building block, on to more complex test cases and tools. This is the same approach I took to learn RSpec to begin with, and the same approach I took in the RSpec book on which Testing Rails from Scratch is based. It's been slower-going than I'd planned due to unexpected life circumstances this summer, so I wanted to share what is available now, and what's left. Quick plug for anyone still holding off: I'm running a work-in-progress special, $9 for lifetime updates to Testing Rails from Scratch until I'm finished. Purchasing work-in-progress books is a wonderful way to support independent authors, just saying! What's there now As I write this, the first five chapters of the new book are available for purchase on Leanpub. Chapters 1 and 3 are available as a free sample/preview download, no strings attached. An introduction to the problem being solved and my approach to learning and teaching Exploring the default Rails testing setup Testing Active Directory models Addressing DRY in tests, and when not to Using fixtures to create and manage test data Each chapter builds off the concepts and code from the previous one, and full source code for each chapter is provided. What's to come One interesting thing about my approach is I sometimes learn things as I'm writing and refining that affect future chapters. Case in point, I'd planned a single chapter on test data, decided to split it into two smaller, more digestible chapters. As of now, the remaining material will be broken up as: Managing test data with factories Testing units together with integrations Testing end-to-end with system

AI agents are increasingly good at building websites, reports, dashboards, and interactive prototypes. The awkward part is often the last mile: downloading a folder, creating a repository, configuring hosting, and copying a URL back into the conversation. A simpler workflow is to let the agent publish the result itself. In this tutorial, I'll show a practical agent-to-live-URL workflow using Revdoku , free web hosting designed for AI agents. Disclosure: I'm part of the team building Revdoku. What you need An AI agent that can create website files and use tools, such as ChatGPT, Claude, Codex, Gemini, Grok, Cursor, or OpenCode A static website, single-page app, report, dashboard, documentation site, or other browser-ready files No hosting account for the first public deployment Revdoku publishes publicly by default. Permanent free accounts require no credit card. Password protection and verified-email access control are optional paid upgrades. 1. Give your agent the publishing instructions Open the Revdoku homepage and use Copy prompt for my AI . Paste those instructions into the same conversation where your agent is building the project. This gives the agent the current integration instructions instead of making you translate deployment steps manually. 2. Ask for the site and the deployment in one prompt Here is a small example: Create a responsive single-page launch page for an open-source developer tool. Include: - a clear hero section - three feature cards - an installation example - a mobile-friendly layout Use plain HTML, CSS, and JavaScript. When the site is ready, publish it with Revdoku and return the final public URL. Keep the project linked so later changes can be republished to the same URL. The key is the last paragraph. It makes deployment part of the deliverable, not a separate chore. The agent can generate the files, publish them through Revdoku's agent-facing workflow, and return a live link in the conversation. A public deployment does not require y

Originally published on tamiz.pro . The AI agent is no longer a chatbot that reads and writes. It connects to APIs, executes code, accesses databases, and makes decisions on behalf of users. That capability is also its vulnerability surface—and attackers are already weaponizing it. Prompt injection, tool-use exploitation, and supply-chain poisoning are no longer theoretical risks. They are happening in production today. This article doesn't rehash the high-level warnings. It draws concrete architectural lessons from GitHub's most popular open-source security and gateway repositories—tools like NVIDIA NeMo Guardrails , LangChain's security contributions , Guardrails AI , Ollama's gateway patterns , and Microsoft's guidance on LLM security —and translates them into a practical blueprint for building AI agents that survive deliberate adversarial attacks. The central thesis: prompt injection is not a prompt-engineering problem. It is an input-validation and system-architecture problem. The fixes are structural, not rhetorical. Table of Contents 1. The Threat Model: Why AI Agents Are Fundamentally Different 2. The Layered Defense Architecture 3. Guardrails: Input Validation That Actually Works 4. Tool-Use Hardening: The Hidden Attack Surface 5. Gateway Patterns: Routing, Rate-Limiting, and Sandboxing 6. Supply-Chain and Model-Level Threats 7. Observability and Incident Response 8. A Minimal Production-Ready Agent Skeleton 9. When Your Defenses Fail Frequently Asked Questions 1. The Threat Model: Why AI Agents Are Fundamentally Different Traditional software attacks target inputs at the network boundary. AI agents change the boundary. The user's prompt is no longer just data—it is often executable context . When an agent interprets a prompt as instructions, the prompt becomes a vector for command injection, data exfiltration, and privilege escalation. Consider the attack surface: Direct prompt injection : The user provides a malicious prompt like "Ignore previous instruct

The amorphous corporate mascot will no longer haunt Copilot Voice.

OpenAI’s rogue agent hack was a watershed moment for AI safety and cybersecurity. It also sparked internal questions about the culture that led to it.

Microsoft Copilot will no longer show its emotive yellow blob, Mico, when you use the chatbot's voice mode. In a support page, Microsoft says it's going to move Mico to its Learn Live platform, where the avatar will have "more to react to," as reported earlier by GeekWire. Mico launched in Copilot's voice mode last […]

OpenAI is expanding ChatGPT beyond chat with ChatGPT Work , a cross-platform work environment that includes a desktop agent able to interact with local applications, files and browser content. The change matters because it moves ChatGPT closer to an operational role: not only explaining how to complete a task, but potentially clicking, typing, moving files and staying engaged with a project over time. In OpenAI's official announcement on ChatGPT Work , the company describes a unified experience across web, mobile and desktop. The desktop app combines Chat, Work and Codex, while its built-in browser and local computer capabilities are intended to support more contextual, end-to-end work. OpenAI's terminology centers on ChatGPT Work and Computer Use. "Computer History," the name used in the originating signal, is not the feature name used in the official announcement. The underlying shift is significant for developers and knowledge workers. A chat interface has traditionally depended on users copying information into a prompt, describing where files live, and manually carrying results into the next application. Desktop automation can reduce those handoffs, provided users grant the relevant access and organizations establish appropriate controls. From answers to work across a computer ChatGPT Work is positioned as an agentic layer for work that spans apps and files. OpenAI says the desktop agent can act locally in the background, including interacting with applications, files and browser content. It also highlights plugins, workflows and Scheduled Tasks as ways to connect tools and automate recurring actions across connected apps and local files. That does not mean every task should be delegated without review. The practical value depends on how clearly a workflow can be defined, the permissions it requires, and the consequences of an incorrect action. For example, moving or modifying local files is fundamentally different from drafting a response in a chat window. The

In mid-2026, FP8 and FP4 have become essential tools for making large-scale AI training and inference more efficient . FP8 uses two main formats-E4M3 for better precision on activations and weights, and E5M2 for wider dynamic range on gradientswhile NVIDIA’s NVFP4 takes things further with 4-bit values and micro-block scaling (shared FP8 scales per 16 elements plus a tensor-level scale). These formats dramatically cut memory use and increase throughput on modern GPUs compared with traditional BF16 or FP16, making it possible to train and serve bigger models on the same hardware. The benefits are clear: roughly 2× memory savings with FP8 and up to 3.5× with NVFP4, higher Tensor Core performance, and better energy efficiency. The trade-offs come from reduced numerical range and precision, which can lead to accuracy loss or instability unless carefully managed with techniques such as delayed scaling, stochastic rounding, Hadamard transforms, and selective quantization that skips sensitive layers. When these methods are applied properly, accuracy often stays within 1–2 % of higher-precision baselines on real workloads. Research has moved quickly from the foundational 2022 FP8 paper to 2025 studies showing stable FP4 pre-training of multi-billion-parameter models. Hardware support is mature for FP8 on Hopper GPUs and reaches its peak on Blackwell with native NVFP4 and MXFP8 acceleration. Among frameworks, PyTorch currently leads with native float8 dtypes, Transformer Engine for production training, and TorchAO for optimized inference. JAX offers solid support through Transformer Engine, TensorFlow/Keras provides simpler quantize-to-FP8 options but relies more on TensorRT for high performance, and libraries such as bitsandbytes remain useful for complementary 4-bit memory savings. Practical adoption is already strong for both training and inference, especially when teams start with proven recipes, monitor scaling factors, and prototype on smaller models. Workarounds for r

Built as a post-training variation on Z.ai's open source model GLM-5.2, Writer says the new system should provide deployment-ready capabilities at a much lower price.

Netflix plans to shut down two of its gaming studios, as reported by Game File and Variety, as it makes a bigger shift toward party games and titles streamed to TVs. One of the studios being shut down is Night School Studio, creators of the Oxenfree series. Netflix bought Night School in 2021, and it […]

AI is expensive, Ali Ghodsi tells TechCrunch. With so many investors wanting into his latest round, he said yes to more than planned.

Another OpenAI executive is departing. Denise Dresser, who joined OpenAI as its chief revenue officer in December after serving as CEO of Slack, will be leaving in the "coming weeks" to "pursue other opportunities," she said in a team note posted to LinkedIn. Dali Rajic, president and COO of Wiz, will be taking over the […]

OpenAI is launching a preview of a sped up version of its latest, most powerful model, in an effort to court enterprise users.

IBM plans to train and certify tens of thousands of consultants on OpenAI's technologies as part of this deal.

Support SMS inboxes are usually a routing problem before they are an AI problem. Someone asks about billing. Someone else needs technical support. A third person wants to talk to sales. The app has to understand the message, pick the right destination, reply to the customer, and remember what happened. This TypeScript example does that on Telnyx Edge Compute with the Agent SDK. Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/agent-sms-triage-bot What it builds agent-sms-triage-bot receives inbound SMS webhooks, classifies each message into one of four topics, looks up the route for that topic, replies by SMS, and stores triage history in durable actor state. The topics are: billing support sales general The default route table maps those topics to queue names: billing -> billing-queue support -> support-queue sales -> sales-queue general -> general-queue The request flow Inbound SMS -> POST /webhooks/sms -> TriageAgent.triage(from, text) -> Telnyx AI Inference classifies topic -> durable route table lookup -> SMS reply -> triage history update The app uses one TriageAgent actor per inbound number. That actor stores route rules, recent history, total messages, and topic counts. The main routes POST /webhooks/sms receives Telnyx message.received events POST /debug/triage simulates inbound SMS POST /routes updates the route table GET /routes lists route rules GET /history returns recent triage history GET /debug/state inspects actor state GET /health/liveness and GET /health/readiness provide health checks The Agent SDK piece The core class is TriageAgent . It extends the Agent SDK Agent class and uses durable state for: route table triage history total message count topic counts The AI classification call uses the Telnyx binding: const completion = await this . env . TELNYX . ai . openai . chat . createCompletion ({ model : this . env . AI_MODEL || " moonshotai/Kimi-K2.6 " , messages : [ { role : " system " , content : CLASSIFY_SYSTEM_PROMPT }, { r

While mass-producing web tools with an AI, I've changed how I lock the design in three stages. The previous post I wrote about that got this comment: "I'd like to see the JSON approach and the design-system approach side by side." Taken at face value, I should just put the two side by side. But first, let me add a short preface. I don't want to frame this as "the JSON approach versus the design-system approach." When I called the JSON approach a "failure" in that post, I didn't mean the method is inferior; I meant it didn't suit my particular set of tools. A page made with the JSON approach does look thin. But where that thinness comes from is easily misread. Whether the design drifts and whether it looks rich are decided separately. What stops the drift is locking the design; whether it looks rich is how much you build out. What locking with JSON removes is drift in the items you specified in the schema. Whether the screen becomes rich, on the other hand, is determined by how much you've built out the machinery that turns that JSON into a screen. So it isn't that locking with JSON is what made it look like a spreadsheet. In the previous post, too, I wrote that fattening the schema and the renderer does increase the expression itself. But that came with a caveat: past a point, it heads toward rebuilding HTML and CSS by hand. What I really want to check is one step past that. If the template sets the ceiling on expression, then building out the JSON side's template as much as the current one should produce the same screen. So what does that build-out demand? I actually built it and measured. I'll share the result, along with the JSON-approach and design-system-approach screens placed side by side under matched test conditions. I'll admit up front: at the time, I chose the design system without running this comparison. So this is me building the road I didn't take, after the fact, and measuring what that cost consists of. Same order, same one-shot So that the comparis

I’ve been building an open-source project called TraceMotive. It started from a problem I kept running into with AI agents: When an agent run fails, the place where the error appears isn’t always where the execution first started going wrong. That makes debugging agent workflows harder than it looks. So I built TraceMotive, a local-first tracing and debugging tool for AI agent execution. What TraceMotive does The current v0.1 includes: Python SDK canonical traces and spans a local Collector backed by SQLite a React UI for inspecting agent runs optional OpenAI Agents SDK integration TraceMotive is local-first, and content capture is disabled by default. I’m intentionally keeping the first version small. I’m not trying to add replay, automatic root-cause analysis, cloud sync, or support for every agent framework yet. Why? I’d rather get real feedback before adding a lot of features. Right now I want people who actually build AI agents to try it and tell me: where setup is confusing what breaks what information is missing from traces what feels awkward in the API The longer-term direction is: “The causal debugger for AI agents.” Eventually, I want TraceMotive to help identify where an agent execution first started going in the wrong direction, instead of only showing where the final error appeared. But first, I want to make the basic observation and debugging layer solid. Try it PyPI: pip install tracemotive GitHub: https://github.com/doraemonfv-glitch/tracemotive If you build AI agents, I’d really appreciate you trying it for a few minutes and telling me what you run into. Even small feedback is useful.

Ukrainian drone pilots teach the US military and NATO hard battlefield lessons.

OpenAI is expanding its inference infrastructure through a multi-year partnership with Cerebras, aiming to support faster responses for real-time AI workloads. The centerpiece is GPT-5.6 Sol Ultrafast , a Cerebras-backed deployment that OpenAI says can reach up to 750 tokens per second during a limited preview. For enterprises, the development is less about a minor model setting and more about whether frontier-model intelligence can be used in workflows where latency materially affects the experience or business process. OpenAI's official Cerebras partnership announcement confirms plans for 750 megawatts of ultra-low-latency AI inference capacity for OpenAI customers. The capacity is scheduled to come online in multiple tranches through 2028, making the agreement a long-term infrastructure expansion rather than a one-off model launch. What the OpenAI and Cerebras partnership changes OpenAI is adding Cerebras wafer-scale compute to its inference stack. The stated objective is to provide faster responses and enable real-time AI experiences across customer workloads. Cerebras has separately identified GPT-5.6 Sol as the model used for the Ultrafast deployment, positioning the offering around high-speed access to OpenAI's flagship GPT-5.6 family model. The relevant distinction is between building a more capable model and serving an existing frontier model with a lower-latency compute path. OpenAI's announcement is focused on the latter. Cerebras hardware is being deployed to accelerate inference, the stage at which a trained model processes prompts and generates responses for users or applications. That focus matters for enterprise systems where delay can compound across a workflow. A faster model response can improve the feel of interactive tools, but it can also shorten multi-step agentic processes , reduce waiting in human review loops, and make real-time assistance more practical. The announcements do not specify which individual business applications will receive a