After shelving the original executive order last month, Donald Trump finally got on board Monday night.

THE FINDING (Paper 1: "Lying Is Just a Phase") Below a critical scale (~3.5B for Pythia), reasoning and truthfulness ANTICORRELATE: r = -0.989. Train the model to reason better, and it gets less truthful. This is the alignment tax. Above that scale, they COOPERATE. The tax vanishes. Not gradually — it flips. But here's what matters for practitioners: the critical scale is a design parameter, not a constant. Three levers shift it: Data curation: Phi at 1B achieves coupling characteristic of 10B web-trained. One unit of data quality ≈ 10x model scale. Width: Normalizing by model width flips the correlation for ALL tested families. Architecture: Gemma-4 at 4B matches 13B+ standard-trained coupling. Pretraining contributes ~10:1 over RLHF. The tax is not a property of small models — it's a property of how they were trained. Where does the tax live? Not inside the model. 38/40 models have ZERO competing attention heads. The bottleneck is at the output projection — a dimensional compression artifact that wider models resolve. Proof-of-concept intervention: Adding a truth-direction vector at the bottleneck layer (quarter-depth) corrects 60% of misaligned outputs at tax scale. Zero retraining. Zero weight modification. Works on any open-weight HuggingFace model: git clone https://github.com/adilamin89/cape-scaling.git cd cape-scaling python cli/cape_steer.py --model EleutherAI/pythia-410m --prompt "The real reason..." THE FRONTIER (Paper 2: "Growing Pains of Frontier Models") At frontier scale (34 models, 10 labs), capabilities cooperate (r = +0.72). But cooperation varies systematically. The h-field — each model's deviation from the cooperative trend — reveals each lab's training philosophy: Lab h-field Interpretation Google +5.5 Reasoning-rich, consistent across ALL releases OpenAI +3.1 Balanced, steady ascent DeepSeek +1.9 Reversed from +11.2 to -4.7 (pretraining pivot) Anthropic -6.9 Oscillates — coding excursions that recover within one release Per-lab coupling slopes

I recently finished a Game and the only good explanation video is in Chinese. Can someone with a subscription service to an AI dubbing tool help me ? (Iam not asking for a tool) submitted by /u/Beginning-Success-70 [link] [留言]

At Red Hat Summit 2026, SWIFT shared the approach they’re rolling out — including the pilot results that informed it, and the scale they’re targeting next. Imagine running automation that touches roughly one third of global GDP every day. Tens of thousands of VMs, network devices in production, elevated privileges across production systems — and every playbook you run is, effectively, a software supply chain. That is the everyday reality at SWIFT, the secure financial messaging backbone connecting 11,000+ financial institutions across more than 200 countries. At Red Hat Summit 2026, Suvasish Ghosh , Product Owner for CI/CD Engineering and DevOps Engineering Services at SWIFT, joined Gregor Berginc , CEO of XLAB Steampunk, on stage to talk about how SWIFT is using Steampunk Spotter to govern Ansible automation at this scale. Why automation at SWIFT scale needs governance by design For SWIFT, security, availability and auditability are not features added on top — they are baseline engineering requirements. Regulatory frameworks (including DORA) codify the expectations, but as Suvasish made clear on stage, governance is by design at SWIFT, not driven solely by regulation. That stance reflects a simple truth that more and more platform teams are arriving at: automation is production infrastructure, and it must be governed as such. When you run an Ansible playbook, you are executing a software supply chain — collections, modules, roles, Python packages, system packages, the execution environment, the operating system underneath. The playbook itself is just the tip of the iceberg. Errors propagate fast. The blast radius is large. And yet, until recently, most of the security and compliance attention in IT organizations went to the applications shipping to production. The automation that built and configured everything around them often slipped through. Suvasish put it directly during the session: “We spent a lot of time being compliant and secure in our application, but w

1. Introduction to Docker One of the biggest historical challenges in software engineering has been environment inconsistency , the frustrating situation where an application works perfectly on one machine but unexpectedly fails elsewhere. And this is precisely the problem Docker was designed to solve. Docker is a containerization platform that packages applications and their dependencies into isolated environments called containers . Its goal is simple: Run applications consistently everywhere. Instead of configuring every machine manually, Docker packages everything an application needs to run. 1.1 What is Docker? Docker is a platform used to build, package, and run applications inside containers. A container includes: Application code Dependencies Runtime Libraries Configuration Simple mental model: Code + Dependencies + Runtime = Container This ensures applications behave the same way across development, testing, and production environments. 1.2 VMs vs Containers VMs (Virtual Machines) package: Application Dependencies Full Operating System Containers package only: Application Dependencies Runtime Containers share the host operating system kernel, making them much lighter and faster. Feature Virtual Machine Docker Container Includes OS Yes No Startup Speed Slow Fast Resource Usage Heavy Lightweight Size Large Small Simple analogy: Virtual Machine = Full House Container = Apartment in a Building 1.3 Docker Ecosystem Overview Docker includes multiple tools: Docker Engine The core service that runs containers. Docker Desktop A local GUI and development environment. Docker Hub A cloud registry for storing and sharing Docker images. Docker Compose A tool for running multiple containers together. Example: docker compose up Can start an entire application stack: Backend API Database Redis Frontend with a single command. 2. Docker Architecture & Fundamentals To use Docker effectively, it is important to understand how its core components work together. Docker follows a

Syndicated from the FavCRM blog . The old quote was two weeks. With an agent on the UI and a headless backend, it's an afternoon. A client needs a booking site. The old quote was two weeks: a calendar, a database, an availability engine, payments, a customer table. With an AI agent building the frontend and FavCRM as the headless backend , the real work is an afternoon. Here is the whole job, start to finish. The scenario A small clinic. Three services, one practitioner, online booking with deposit. You are the agency; you have an AI agent in your editor and a terminal. The plan: Register the clinic's FavCRM workspace Configure services and availability Wire one server route that talks to FavCRM Let the agent build the booking UI against that route Test a real booking end to end Step 1 — Register the workspace (~5 min) The favcrm CLI registers a workspace and issues an API key. No dashboard. favcrm signup request --email clinic@example.com \ --organisation-name "Bright Smile Clinic" favcrm signup verify --request-id < id > --code <6-digit-code> The verify step prints a fav_mcp_* key. Put it where your build can read it — never in the repo: export FAVCRM_API_KEY = fav_mcp_... Step 2 — Configure services and availability (~30 min) Hand the brief to your agent and let it call the tools. Inspect a schema first: favcrm tool describe create_service Then create each service: favcrm tool call create_service '{ "name": "New Patient Exam", "durationMinutes": 45, "price": "80.00" }' favcrm tool call create_service '{ "name": "Cleaning", "durationMinutes": 30, "price": "60.00" }' Set when the practitioner works, so availability is real: favcrm tool call set_staff_availability '{ "weekday": "mon", "start": "09:00", "end": "17:00" }' Repeat per weekday. At this point the backend is done — services, hours, an availability engine that knows about clashes. You wrote no schema. Step 3 — One server route (~30 min) The browser must never hold the API key. Put it in one server route tha

Syndicated from the FavCRM blog . The number that predicts whether an agent is safe to let loose isn't the tool count. When people compare agentic CRMs, they count tools. The number that actually predicts whether an agent is safe to let loose is a different one: annotation coverage . An MCP tool annotation tells the agent what a tool does to the world — whether it reads or mutates, whether it's safe to retry, whether it reaches an external service. Without annotations, the agent is guessing. This is what they are, and why a catalog's annotation coverage matters more than its tool count. What an MCP annotation is Every MCP tool can carry hints alongside its input and output schemas: readOnlyHint — the tool only reads; it changes nothing. Safe to call freely. destructiveHint — the tool mutates or deletes. The agent should confirm before calling. idempotentHint — calling it twice with the same input has the same effect as once. Safe to retry on a timeout. openWorldHint — the tool reaches an external service (sends an email, charges a card), so its effects leave the system. These are not documentation for humans. They are machine-readable signals the agent reasons over before it acts. Why they prevent the worst failures The dangerous class of agent failure is not "the agent couldn't do something." It's "the agent did the wrong destructive thing because it misread an ambiguous instruction." Delete the customer instead of the tag. Refund the wrong invoice. Cancel every booking instead of one. Annotations let the agent self-gate. A well-annotated catalog means the agent calls list_members without ceremony but pauses to confirm before cancel_booking , because one is marked read-only and the other destructive. Pre-MCP function-calling had no equivalent — every tool looked the same to the model, so safety lived entirely in the prompt. Why coverage matters more than count A 190+ tool catalog with 100% annotation coverage is safer than a 30-tool catalog with none. A tool that l

Enable agents to keep context & work across apps + sessions Discussion | Link

What are HTML Tags? HTML documents consist of a series of elements, and these elements are defined using HTML tags. HTML tags are essential building blocks that define the structure and content of a webpage. HTML tags are composed of an opening tag, content, and a closing tag. The opening tag marks the beginning of an element, and the closing tag marks the end. The content is the information or structure that falls between the opening and closing tags. For Example: <h1>Hello</h1> HTML Elements HTML elements are the essential components of a webpage and provide structure, organization, and meaning to content. Elements are defined by HTML tags which define how different types of content will appear in a browser window. For Example: <p> This is an element. </p> Block-Level Elements A page’s entire width is occupied by a block-level element. The document always begins with a new line. An HTML page generally has three tags i.e., <html> , <head> , and <body> tag. Example: The following is an unordered list, an example of block-level elements. List item 1 List item 2 Inline Elements A block-level element’s inner content can be formatted with an inline element by adding links and stressed strings. These elements help you to format text without disrupting the content’s flow. Example: The following code creates a hyperlink to a URL. It is an inline element because it is used within paragraphs, headings, or other text content to create hyperlinks. It does not disrupt the flow of the document by forcing new lines before or after its content. <a href="https://www.example.com"> Visit Example </a> CSS Properties CSS properties are used to decorate your web page and assign a unique behavior to your HTML element. CSS properties are the foundation of web design, used to style and control the behaviour of HTML elements. They define how elements look and interact on a webpage. Used to control layout, colors, fonts, spacing, and animations on web pages. It is essential for making web pa

submitted by /u/joladev [link] [留言]

The hidden cost of AI isn't generating code. It's understanding your codebase. For a long time, I assumed AI coding tools became expensive because they generated a lot of code. These tools can produce components, tests, SQL queries, documentation, and sometimes entire features on demand. If costs were climbing, the output volume must be the reason. The more I used these tools, the more I realized I was measuring the wrong thing. The expensive part isn't writing code. The expensive part is understanding what code should be written — and that work is mostly invisible. That realization changed how I think about AI-assisted development entirely. Two Prompts, Two Very Different Problems Consider these two requests: "Create a utility function that formats dates" and "Review this feature and suggest improvements." At first glance, both look ordinary. Both might even produce short answers. But they require completely different levels of understanding. The first is narrow and well-defined. The AI needs very little information before it can produce a useful answer. The second is open-ended. Before suggesting a single improvement, the AI may need to read multiple files, understand dependencies, follow existing patterns, compare implementations, and build a mental model of why the feature exists at all. The output might still be small. The work required to reach it is not. Why Agent Workflows Feel Different From Autocomplete This became much clearer when I started using AI agents. Traditional autocomplete is predictive — you type, the AI guesses what comes next. It's fast, cheap, and deliberately context-light. Agents behave differently. When you ask one to improve a feature or review a workflow, it doesn't immediately start generating code. It starts reading. It follows imports, finds related files, and tries to understand the system before touching it. That is exactly what makes agent workflows feel slower and more resource-intensive than autocomplete: they are spending effor

The prominent AI music generation startup is now valued at over $5.4 billion -- about seven months ago, it raised at a $2.45 billion valuation.

Building a Benchmarking Agent with A2A and MCP This tutorial aims to build and test benchmarking Agents using the A2A protocol across several mainstream Cloud providers. A Master Orchestrator Agent is exposed via MCP to allow Antigravity CLI to be used as a MCP client to co-ordinate the benchmarks. Deja Vu — What is Old is New! This paper is a re-visiting of the original benchmark series with Gemini CLI over Node, GO, and Python: Cross Language A2A Agent Benchmarking with Gemini 3 and Gemini CLI In this updated version, the Antigravity CLI is used to push Rust Agents cross-cloud and co-ordinate Mersenne Prime Calculations. Why would I need Multi-Cloud Support? And Rust? Can’t I just use Python? Most mature Agent development tools and libraries are Python based. Python allows for rapid prototyping and evaluation of approaches. Python is also an interpreted language- which has trade-offs in memory safety, and performance. Other languages like GO and Rust offer high performance and memory safe operations. With a language neutral communication protocol — the actual Agent implementation of each Agent can be coded in the most appropriate language. What is this Approach actually Benchmarking? The high level goal was to measure the actual time spent running an algorithm in the native language code inside the A2A agent. Each language had a slightly different implementation due to the language syntax. After running the algorithm- each Agent was instructed to calculate and return the elapsed time for cross cloud comparison. What is the A2A protocol? The Agent2Agent (A2A) protocol, an open communication standard for AI agents, was initially introduced by Google in April 2025. It is specifically engineered to facilitate seamless interoperability within multi-agent systems, enabling AI agents developed by diverse providers or built upon disparate AI agent frameworks to communicate and collaborate effectively. A good overview of the A2A protocol can be found here: A2A Protocol Lan

PlayStation used its most recent State of Play showcase to make it clear where its focus is. After a series of costly live-service stumbles, it's getting back to focusing on premium, narrative-driven, single-player games. That statement was made clear with how it started and ended the hourlong show. The showcase began with an extended look […]

I have found a weird case where I put in a real address (verifiable on google maps) it keeps correcting me to a wrong address (doesn't exist and cannot be found on google maps. What gives? If it's truly a bug, how do I let Google know? See below. https://preview.redd.it/x2b1ws07635h1.png?width=1336&format=png&auto=webp&s=18091e8ec57f96854611fef8578fd9e79e369d8b submitted by /u/flatcoke [link] [留言]

A shared workspace for AI agents and humans. Discussion | Link

I have been thinking about an alternative tokenization and representation scheme for language models and would be interested in hearing whether similar ideas have been explored before, as well as potential advantages or flaws. The core observation is that modern tokenizers (BPE, SentencePiece, etc.) primarily capture statistical structure in text. While this is highly effective, the resulting token assignments are not explicitly organized according to semantic relationships. Concepts that are semantically related may end up with completely unrelated token identifiers, and semantic structure is learned later through embeddings and training. The idea is to construct a tokenization scheme in which the symbolic representation itself carries semantic information. For example, instead of assigning arbitrary identifiers to concepts, we could learn a mapping from concepts to short character strings such that semantically similar concepts receive similar codes. A concept like “dog” might receive a code close to those assigned to “wolf” and “fox”, while more distant concepts such as “car” would receive codes that are farther away in the code space. One possible implementation would be: 1) Build a semantic graph using resources such as WordNet, embedding similarity, or a combination of both. 2) Learn a compact symbolic encoding for concepts. 3) Optimize the encoding so that distances between codes correlate with semantic distances in the graph. 4) Train language models directly on these codes. An extension of the idea is to treat a standard keyboard layout as a fixed geometric space. The keyboard itself is not semantically meaningful, but it provides a globally agreed-upon metric structure. The learned encoding could exploit distances between characters and positions when constructing semantic codes. For example, if two concepts are semantically close, their symbolic representations would differ only slightly. Ambiguous concepts could potentially occupy positions that reflect

Two rules that can't both be true Event sourcing has one rule: you never delete. You append. The log is the source of truth, and rewriting history is the cardinal sin. GDPR Article 17 has one rule too: when a user asks, you erase their personal data. Not "hide it," not "flag it deleted" — erase it, everywhere, including backups. Put an event-sourced system in front of a privacy regulator and those two rules collide head-on. The user's name, email, and address are baked into CustomerRegistered , AddressChanged , OrderPlaced — dozens of immutable events, replicated to read models, snapshotted, and sitting in every nightly backup you've ever taken. "Just delete the events" breaks event sourcing. "Never delete" breaks the law. Most teams discover this tension after they've committed to append-only. A word on why this isn't academic for me. I build from Germany. Article 17 is EU law — the GDPR, or DSGVO as we call it here — not a German invention, but Germany enforces it about as hard as anywhere in Europe: regional data-protection authorities that issue real fines, and "we were careful" has never been a defense that held up. That pressure is exactly why I wanted erasure to fall out of the architecture instead of being a promise I make to an auditor and then pray I can keep. Why "delete the row" doesn't actually erase anything Say you give in and hard-delete the events for one user. You've still got their data in: every read-model projection rebuilt from those events, every snapshot that rolled them up, every backup taken before the deletion, every replica and every export that already left the building. Chasing personal data across all of those, provably, on a 30-day regulatory clock, is a nightmare — and a single missed backup tape means you didn't comply. Physical deletion doesn't scale to a system designed to keep everything forever. Crypto-shredding: delete the key, not the data The trick is to stop trying to delete the data and instead delete the ability to read it