标签：#AI

What if the AI you chat with every day is quietly running something that looks a lot like a train of thought, and we just never had the right tool to see it? On 7th July, 2026, Anthropic published a research paper that honestly feels a little spooky. The team behind the Transformer Circuits Thread released a long, detailed study called Verbalizable Representations Form a Global Workspace in Language Models . The title is dense, but the idea inside is wild. They found a small, privileged region inside Claude and similar models. A region that behaves a lot like what cognitive scientists call the global workspace , the part of the brain associated with conscious access. The part that lets you say, I am thinking about a banana right now . In this post, I want to walk you through what they found, in plain English, with no math fear and no jargon walls. We will cover what the workspace is, how they found it, what they can do with it, and why it matters for anyone building or using AI. Grab a coffee. This one is worth your time. First, a Quick Brain Detour Before we get to the model, we need a tiny bit of background from neuroscience. For decades, scientists have noticed that the brain seems to operate on two tracks. Most of what your brain does, like parsing the sounds coming into your ears or keeping you balanced, happens automatically and quietly. You cannot really talk about it . It just runs in the background. But a smaller slice of brain activity is different. It is reportable . You can put it into words. You can hold a concept in mind, dismiss it, chain it to another concept, and use it for reasoning. Cognitive scientists call this access consciousness . One popular theory, called the Global Workspace Theory , says this happens because the brain has a shared hub. Specialized processors do their own thing in parallel. But every now and then, a representation gets posted to this central workspace, and once it is there, lots of other brain systems can read it, reason w

Most agent demos are one-shot loops. You open a terminal, give the model a task, watch it call tools, and then the process dies. That is fine for coding sessions. It is a weak shape for an assistant that is meant to live in your actual workflow. Talon is built around the other shape: a persistent agent process with frontends, memory, tools, background jobs, and swappable model backends. What it runs on Talon can expose the same agent core through: Telegram Discord Microsoft Teams terminal chat a desktop/mobile companion bridge That means the agent is not tied to one UI. The chat app is just a mouth. The core state, tools, memory, goals, and model backend live behind it. Backends are swappable The same harness can run through: Claude Agent SDK OpenAI Agents Codex Kilo OpenCode Each backend implements the same capability interface, so the rest of the system does not need to care which model runtime is active. It has real operating machinery The important parts are not flashy. They are the things that let an agent keep working after the first message: MCP plugins for tools cron jobs for scheduled actions triggers for condition-based wakeups persistent goals for multi-session work long-term memory heartbeat mode for background progress dream mode for consolidation per-chat model and effort settings This is the difference between "chat with a model" and "run an assistant". Install npm install -g talon-agent talon setup talon start Repo: https://github.com/dylanneve1/talon If this is the kind of agent infrastructure you want more of, a GitHub star helps the project get found.

We've all seen password strength meters on sign-up forms. Most of them rely on simplistic, static rules: "Must contain at least 8 characters, one number, and one special character." But from a mathematical standpoint, these rules are a poor proxy for actual password security. A password like Tr0ub4dor&3 conforms to these rules but is far easier to compromise than a randomly generated four-word passphrase like correct-horse-battery-staple . To truly measure password security, we have to look at information theory and compute its Shannon Entropy . Here is how password entropy works, the math behind it, and how you can calculate it directly in the browser with 100% client-side privacy. What is Password Entropy? In cryptography, entropy is a measure of the unpredictability or randomness of a password. It is expressed in bits . An entropy of $N$ bits means there are $2^N$ possible combinations that an attacker would have to guess in a worst-case brute-force search. < 28 bits: Very weak (easily guessed in milliseconds). 28 to 35 bits: Weak (cracked in minutes or hours). 36 to 59 bits: Reasonable protection (days to months). 60 to 127 bits: Very strong (takes years to decades to crack). 128+ bits: Extremely secure (mathematically unfeasible to crack). The Mathematical Formula To calculate the entropy ($E$) of a password, we use the following equation: $$E = L \times \log_2(R)$$ Where: $L$ is the length of the password (number of characters). $R$ is the size of the pool of unique characters from which the password is drawn. $\log_2(R)$ is the binary logarithm of the pool size, representing the amount of information carried by each character. Determining Pool Size ($R$) To find $R$, we analyze which character sets are present in the password string: Lowercase letters ( a-z ): 26 characters Uppercase letters ( A-Z ): 26 characters Numbers ( 0-9 ): 10 characters Common special characters/punctuation: 33 characters (e.g., !@#$%^&*()-_=+[]{}|;:',.<>/? etc.) If a password uses ch

Vermilion Cliffs Ventures announced Wednesday the close of a $25 million Fund II.

Build a new kind of rocket engine and the world will beat a path to your door.

Itamar Friedman discusses how architects and engineering leaders can break through the AI productivity ceiling using adaptive multi-agent systems. He shares insights on moving past simple autocomplete to resilient workflows by integrating autonomous testing, intelligent code review, and robust arbitration. Learn how to govern agent communication and build a context-driven SDLC that scales. By Itamar Friedman

Blue Origin is raising $10 billion at a $130 billion pre-money valuation from Coatue Asset Management, Bezos himself, and other big-name investors, The New York Times reported.

Learn how OpenAI approaches government and national security partnerships, with principles for responsible AI use, democratic accountability, and public safety.

Miners backed by Trump admin. sell to Japan, South Korea despite push to develop domestic supply chain.

The therapy unit at the hospital I work for had six treatment rooms. Room 1, Room 2, Room 3, and so on, each split by the kind of therapy it handled. And each room kept its own document to record patients. The problem wasn't that the documents existed. The problem was that no two of them looked alike. Same patient. Same information. But every room ordered the columns differently and named things differently. One put the date in the first column. Another put it last. One wrote "treatment time." The room next door wrote "minutes used." On their own, each form worked fine. Looked at one at a time, there was nothing wrong. The trouble showed up the moment anyone tried to combine them. The work that never ended Every so often, a request would come down from above: Can we see the overall numbers? That was when the real work began. I would open all six documents side by side. I would line up columns that didn't match, by eye, and move each value into one master table by hand. Days of this would get me a single sheet of statistics. Then the next quarter, the same request came down again. And I started over. The table I'd built last time was useless if the format had shifted even slightly. So I rebuilt it from scratch. Every time. I couldn't stand it. This was obviously a job you do right once and never touch again. We just weren't doing it right. So instead, we kept feeding people's evenings into it. The obvious answer The fix was simple. Make all six rooms use one form. Same columns. Same names. Same order, everywhere. Then there's nothing to move when you combine them. The statistics become a matter of stacking, not translating. The answer was so obvious I wondered why nobody had done it years ago. So I built a unified form in Excel and sent it around. And that's where I learned Excel has walls of its own. Where Excel broke down Once a file gets passed around, you lose track of which copy is the real one. The versions pile up. "Final." "Actually final." "Final, revised."

In the world of project management and team collaboration, the holy grail is reducing friction. Previously, we looked at how to make Trello cards talk back The Power of Gemini inside Trello and how to bring Gemini into your workspace Gemini in your Slack workspace . But what if you wanted a highly intelligent, stateful team assistant living directly in Slack that could answer complex, open-ended questions about your Trello boards? Questions like: "Which cards did I edit last week?" "Show me all comments made across my active boards in the last 7 days." "What is the current status of the card XYZ?" Answering these questions requires more than simple semantic search; it requires a tool that can dynamically write retrieval scripts, parse complex multi-board JSON payloads, filter dates, and compile elegant reports. In this article, we'll explore how to build exactly that using Google’s Antigravity Managed Agent (the "Agy" agent) , integrated into Slack's native Agent View , utilizing a secure, stateful, and sandboxed remote execution environment. 🚀 Prerequisites Before starting, make sure you have: A Google AI API Key with Gemini / Antigravity access A Trello Account (with an API Key and Token for read-only board queries) A Slack Workspace (with App Admin privileges to create a Socket Mode app) Node.js (v24+) and pnpm (v11+) installed 🔒 Security & Environment Controls: The Agy Sandbox Philosophy At the heart of this setup is Google's Antigravity (Agy) Managed Agent . Instead of running in a transient stateless environment, the Agy agent operates inside a persistent, secure, and remote Linux sandbox equipped with standard execution engines (Python, Node.js, bash, etc.). When a Slack user asks a question, the Agy agent dynamically writes a script, runs it in its isolated sandbox, inspects the Trello API output, self-corrects if any errors occur, and presents a formatted response. In this article, we focus on Trello, but the same principles can be applied to any other syst

I initially wanted to **make a side-scrolling game like MapleStory**. YouTube was flooded with "I made a game with AI (Claude)," so I thought it would be easy. But when I tried it myself – it turned out that **people with existing game development knowledge were just using AI to improve quality and speed**, not that you could just "make it for me" without any knowledge. In the end, what I completed wasn't a playable game, but an **"auto-battle" spectator game** (like raising a mushroom) that you just watch. This post is about that **honest journey** – where I got stuck, why I pivoted, and what I learned. (And you can try out the completed version via the **🎮 Play Now** link below.) I'm a developer in Korea building an AI chatbot alone. I only write about things I've **actually tried and experienced**.## 1. The First Wall — AI-Generated Characters Can't 'Walk' **Moving characters** are essential for games like MapleStory. So, I first tried **AI image generation (gpt-image) to create chibi characters** and then generated walk cycles (4 frames of walking animation) for them. This is where I got stuck. **With each frame, the character subtly became a different character** – the color of the clothes, the proportions, the face all changed slightly between frames 1, 2, 3, and 4. When stitched together in a game, the character wouldn't walk; it would just **tremble erratically.** The Ceiling of Character Animation — AI Generation vs. Pre-made Sprites ❌ AI-Generated Characters (Re-imagined each frame) 🧍1 🧎2 🕴️3 🧍4 → Clothing/proportions wobble each frame = 'Trembling' instead of walking ✅ Pre-made CC0 Sprites (Hand-drawn sheet) 🏃1 🏃2 🏃3 🏃4 → Consistent frames = Smooth walk cycle This is **exactly the same ceiling** I hit in Making AI Videos (Dev Log #3) – AI image generation **cannot create consistent character animation (multi-frame movement).** The same wall in videos, the same wall in games. 2. Pivot ① — Abandoning AI Characters for Pre-made Sprites So, my first surrender

Quantum mechanics gave us the transistor before we understood it. The same pattern is happening with AI right now — and the builders who recognize this will define what comes next. The argument that never ended — and the lab that didn't care In 1927, the greatest minds in physics gathered in Brussels for the Solvay Conference. Albert Einstein, Niels Bohr, Werner Heisenberg, Erwin Schrödinger, Max Planck, Marie Curie — twenty-nine of the most brilliant humans who ever lived, in one room. They were arguing about quantum mechanics. Specifically: what does it mean for a particle to exist in multiple states simultaneously until observed? Does reality require an observer? Is the universe fundamentally probabilistic? Is God playing dice? Einstein said no. Bohr said yes. Neither convinced the other. That argument never fully resolved. Nearly a century later, physicists still debate the interpretation of quantum mechanics — the Copenhagen Interpretation, Many Worlds, Pilot Wave theory. We have not settled it. Meanwhile, in 1947 — twenty years after the Solvay Conference — three engineers at Bell Labs in New Jersey quietly invented the transistor. William Shockley, John Bardeen, and Walter Brattain did not wait for the philosophical debate to conclude. They did not need to understand why quantum tunneling worked at a fundamental level. They understood it well enough to build something with it. That transistor became the foundation of every computer, every smartphone, every server, every piece of digital infrastructure that exists today. We built the entire digital civilization on something we still don't fully understand. Not despite the uncertainty. With it. The pattern repeating right now Across the internet in 2025 and 2026, a remarkably similar argument is happening. Will AI take all the jobs? Is it conscious? Does it hallucinate too much to be trusted? Are we building something we cannot control? Should we slow down? Should we stop? These are not trivial questions. The r

🎯 Learning Objectives Understand the interface boundary between Terminal Emulators and Shell Interpreters (including Windows Terminal vs. PowerShell vs. CMD). Master File System path tracking, hidden dotfiles, and essential CLI utilities. Map system execution paths via global and local environment configurations. 1. Terminal vs. Shell (The Windows Architecture) Terminal: The visual GUI wrapper. A window application that captures keyboard strokes, handles GPU text rendering, and manages tabs/panes. Examples: Windows Terminal, iTerm2, Alacritty. Shell: The command interpreter engine running inside the terminal. It evaluates text strings, processes scripts, issues system calls ( syscalls ), and interacts with the OS Kernel. Examples: PowerShell, Bash, Zsh, Command Prompt (CMD). ┌────────────────────────────────────────────────────────┐ │ WINDOWS TERMINAL GUI (The Visual Interface Window) │ │ │ │ │ ├───► Tab 1: [ PowerShell Core Engine (Modern) ] │ │ ├───► Tab 2: [ Command Prompt Engine (Legacy) ] │ │ └───► Tab 3: [ WSL Ubuntu Linux Bash (Core) ] │ └───────────────────────────┬────────────────────────────┘ │ Raw Text & Input Streams ▼ ┌────────────────────────────────────────────────────────┐ │ SHELL INTERPRETER (e.g., PowerShell / CMD) │ │ └───► Parses input string commands into system tasks │ └───────────────────────────┬────────────────────────────┘ │ System Call (Syscall) ▼ ┌────────────────────────────────────────────────────────┐ │ OPERATING SYSTEM KERNEL │ │ └───► Interacts directly with underlying hardware │ └────────────────────────────────────────────────────────┘ 2. Deep Dive: PowerShell vs. Command Prompt (CMD) While both are Windows shells hosted inside Windows Terminal, they belong to entirely different computing eras: Command Prompt ( cmd.exe ): A legacy text shell maintained purely for backwards compatibility with 1980s MS-DOS. It pipelines data as Plain Text Only , meaning outputs must be manually string-filtered. PowerShell ( pwsh.exe ): A modern, cros

Artificial intelligence has become one of the most discussed technologies in education. From automated grading systems to AI chatbots capable of answering complex questions, many people wonder whether AI will eventually replace teachers. The short answer is no. Education has never been just about delivering information. Great teachers inspire curiosity, understand students' emotions, adapt to different learning styles, and create environments where learners develop critical thinking. These are deeply human abilities that artificial intelligence cannot fully replicate. However, AI is beginning to solve a different problem: helping students learn independently outside the classroom. The Problem With Traditional Self-Study Many students spend hours reading textbooks without truly understanding the concepts. When they encounter a difficult paragraph, they often search the internet, only to find lengthy articles, conflicting explanations, or answers that are either too advanced or completely unrelated to their curriculum. This creates an inefficient learning process where students spend more time searching than actually learning. Another common challenge is passive learning. Reading a chapter once often creates the illusion of understanding, but without testing knowledge through questions or applying concepts, much of that information is quickly forgotten. How AI Can Support Learning Modern educational AI systems are becoming less like search engines and more like interactive learning companions. Instead of simply returning search results, these systems can explain concepts in simpler language, adapt explanations to a student's academic level, answer follow-up questions, generate practice quizzes, and even identify areas where additional practice is needed. This creates a much more personalized learning experience. Learning From Personal Study Materials One of the most interesting developments in AI education is the ability to work with a student's own resources. Rather

Enterprises are now talking about AI coding agents in a very predictable way. The first question is usually: "How much more code can it help us generate?" It is not a wrong question. But if that is the only question, the ROI calculation will probably be wrong. Because enterprises are not really buying "more code." They are buying: faster delivery less rework lower maintenance cost better developer experience more stable software quality more controllable security and compliance risk faster translation from product capability to business value Code generation is an input. It is not the outcome. That distinction matters. An AI coding agent can help developers write functions, fix bugs, add tests, generate documentation, understand codebases, and refactor legacy systems. That sounds powerful. But the enterprise question is not: "How many lines of code did it generate today?" The better question is: Did that code reach production faster? Did incidents go down? Did the team spend less time on repetitive work? Did customers get value sooner? If the answer is unclear, generating 100,000 lines of code a day may simply mean producing technical debt faster. The short version: AI coding agent ROI does not end inside the IDE Many teams start measuring AI coding tools with the most obvious numbers: code suggestion acceptance rate lines of code generated number of active users number of prompts time saved on individual tasks These metrics are useful. But they mostly show that the tool is being used. They do not prove that the enterprise is getting value. Enterprise ROI has to be measured across software delivery, quality, risk, and business outcomes. In other words, an AI coding agent is not just a point solution for individual efficiency. It affects the entire software value stream: Request -> Design -> Coding -> Review -> Testing -> Deployment -> Monitoring -> Feedback -> Business outcome If you calculate value only inside the "coding" box, you miss the bigger picture. Why "amo

Why I Choose Lovable for Building Full-Stack Applications with AI Over the last year, AI-assisted software development has evolved from generating code snippets to building complete web applications. We've all seen tools like Cursor, Claude Code, GitHub Copilot, Replit Agent, Bolt, and many others enter the market. Each has its strengths, but after experimenting with several of them, I keep coming back to Lovable whenever I want to build a new web application from scratch. This isn't a sponsored post—it's simply the workflow that has worked well for me. If you're interested in trying Lovable, you can use my referral link below. Disclosure: new users receive additional signup credits, and I receive referral credits if you sign up through it. Referral: https://lovable.dev/invite/AQ02SOZ Why Lovable Stands Out Most AI coding assistants help you write code. Lovable helps you build an application. Instead of focusing on individual functions or files, it takes a higher-level approach where you describe what you want, and it generates a complete full-stack application that you can continue refining. A typical workflow looks like this: Idea │ ▼ Describe the application │ ▼ Lovable generates • Frontend • Backend • Database • Authentication • API integration │ ▼ Preview instantly │ ▼ Connect GitHub │ ▼ Iterate and Deploy Unlike traditional no-code platforms, you're not locked into a proprietary editor. Lovable supports GitHub synchronization, native Supabase integration for authentication and PostgreSQL-backed data, and deployment options ranging from Lovable-hosted apps to your own infrastructure. Why I Keep Choosing Lovable After building several side projects, these are the reasons I continue to use it. 1. Rapid idea-to-production workflow The biggest productivity gain isn't AI-generated code. It's reducing the number of decisions needed before users can interact with your application. Instead of spending hours creating project structure, authentication, routing, database

You start the morning with four Claude Code agents running, each in its own git worktree, each on a separate task. By mid-afternoon something is off. One agent has re-implemented a helper another already wrote. A second built against an interface that a third changed an hour ago. A fourth made a naming choice that contradicts a decision you made — out loud, to yourself — at 9am. Every diff is reasonable on its own. The system they add up to is not. This is the failure mode that shows up the moment you go from one agent to several. The code each agent produces is fine. What drifts is everything between the agents: the decisions, the conventions, the current shape of the interfaces they all depend on. Running the agents in parallel is the easy part. Keeping them coherent is the hard part, and it's a different problem. Why parallel agents drift An agent's context is per-session. Each Claude Code instance has its own context window, populated by what it has read and done in that session. Nothing about that window is shared with the agent running in the next worktree. There is no common memory they all write to and read from. So when agent A decides "we use the repository pattern for data access," that decision exists in exactly two places: agent A's context, and your head. Agent B never hears about it. Three kinds of state cause the drift, and they're worth separating because they need different handling: Decisions already made. Architecture, naming, conventions, the approach you settled on for a cross-cutting concern. These are durable — once made, they should bind every agent, including ones you spawn tomorrow. The current contract. The shape of the interfaces, types, and APIs that agents share. This changes during the work: agent A edits a signature, and agents B and C are now building against a version that no longer exists. What's in flight. Who is touching which files right now. Two agents editing the same module in separate worktrees won't see each other until th

Kevin Weil's new role at Stoke Space suggests reusable rockets are the next hot thing in Silicon Valley.

For the last couple weeks, I've been in an extremely lucky position: I've been spending a lot of time playing games on Valve's Steam Machine. We gave the Steam Machine a 6, and I don't disagree with my colleague Sean Hollister's review. But even though I already own a PS5 and an Xbox Series X, […]