DeductiveAI, a startup that uses AI to catch and resolve bugs in software, was founded just three years ago.

Your repo is already your agents' context, whether you designed it on purpose or not That sentence took me a while to understand. In this post I'll save you the trip. It was October 2025, working in Skyward's monorepo with AI agents every day. And every day the same routine: I'd tell the agent in the prompt "don't use this", "don't do it this way", "reuse the component that already exists". I wrote it down. I repeated it. The agent did exactly what I told it not to do. It wasn't that it didn't listen to me. It was that it read the code and saw something else there. The agent believes the code, not your prompt An agent follows the patterns it sees in the repo, not the ones you tell it in the prompt. And subagents are worse, because they start without the conversation's context. The whole fight you put up earlier in the chat, for them it never happened. So this is what kept happening. It created a new component even though one already existed that solved exactly that problem. It didn't respect the design rules or use the design tokens. It followed stale docs because they were still there, alive, with nothing flagging them as outdated. My first instinct was everyone's instinct, cram more context into the prompt. More rules, more "please don't do this", more examples pasted in by hand. It half worked, and for the next task you had to add it all again. Until the next subagent showed up and started from scratch. At some point, tired of repeating myself, I understood the obvious thing. The agent wasn't disobeying me. It was reading the repo and listening to what the repo said about itself. If the good component lives alongside three old versions, it has no way to know which one is the official one. If the docs say one thing and the code does another, it'll believe whichever is closest at hand. It's doing exactly what I asked. The repo itself is the context agents use. If it's badly structured, the answers won't be good. Period. No prompt fixes a repo that contradicts itsel

Tu repo ya es el contexto de tus agentes, lo hayas diseñado a propósito o no Esa frase me costó entenderla. En este post te ahorro el camino. Era Octubre del 2025, trabajando en el monorepo de Skyward con agentes de IA todos los días. Y todos los días la misma rutina: le decía en el prompt al agente "no uses esto", "no hagas esto así", "reutiliza el componente que ya existe". Lo escribía. Lo repetía. El agente hacía exactamente lo que le dije que no hiciera. No era que no me escuchara. Era que leía el código y ahí veía otra cosa. El agente le cree al código, no a tu prompt Un agente sigue los patrones que ve en el repo, no los que tú le dices en el prompt. Y los subagentes son peores, porque arrancan sin el contexto de la conversación. Toda la pelea que tú diste arriba en el chat, para ellos no existió nunca. Entonces pasaba esto. Creaba un componente nuevo aunque ya había uno que resolvía exactamente el problema. No respetaba las normas de diseño ni usaba los design tokens. Seguía documentación obsoleta porque seguía ahí, viva, sin nada que la marcara como obsoleta. Mi primer instinto fue el de todos, meter más contexto en el prompt. Más reglas, más "por favor no hagas esto", más ejemplos pegados a mano. Funcionaba a medias, y para la siguiente tarea había que volver a agregarlo todo. Hasta que llegaba el siguiente subagente y empezaba de cero. En algún momento, cansado de repetirme, entendí lo obvio. El agente no me estaba desobedeciendo. Estaba leyendo el repo y haciendo caso a lo que el repo decía de sí mismo. Si conviven el componente bueno y tres versiones viejas, no tiene cómo saber cuál es el oficial. Si la doc dice una cosa y el código hace otra, le va a creer al que esté más a mano. Está haciendo justo lo que le pedí. El mismo repo es el contexto que usan los agentes. Si está mal estructurado, las respuestas no van a ser buenas. Punto. No hay prompt que arregle un repo que se contradice a sí mismo. Screaming Architecture me llevó hasta media cancha Lo prim

"I consider this a success already, just from the fact that we're even going to try this."

This is a submission for the June Solstice Game Jam What I Built I built a simple cipher game with 6 levels to decrypt the cipher text based on frequency of words and hints to obtain the plaintext version. Video Demo Code samarthsubramanya / JuneSolstice_GameJam_2026 ☀ Solstice Cipher A code-breaking puzzle game built for the June Solstice Game Jam — and a small ode to Alan Turing . Six encrypted messages stand between you and the longest day of the year. Each one is a substitution cipher hiding a message about a June celebration — International Sushi Day, the World Cup, Pride, Juneteenth, Turing himself, and the solstice. Crack each cipher using frequency analysis (the same statistical reasoning Turing's team used at Bletchley Park) and the sun climbs a little higher with every solve. Break all six and you bring the light all the way back. Theme The June solstice is a global moment of transition — the longest day in the north, the shortest in the south. The game makes that literal: decoding is the act of bringing back the light. A night sky brightens into dawn as your accuracy rises, a Pride rainbow… View on GitHub june-solstice-game-jam-2026.vercel.app How I Built It I built it using ReactJS and hosted on vercel. I implemented a simple frontend with no backend dependency session-specific experience for simplistic approach Using hardcoded values and configuration. Prize Category Generated with Assistance from Google AI through Antigravity.

Every startup idea looks perfect... until you start building. The first version of PixoraCloud looked amazing on paper. Then reality hit. We discovered: Some features weren't necessary Some APIs were too complicated Some ideas solved our problem, not the user's problem So we changed them. A lot. That's where we are today. Not chasing perfection. Chasing simplicity. Building in public means admitting your first idea isn't always your best one. What's one thing you've completely changed after starting a project?

Architecture Overview Clioloop's Agentic Fusion is not just "run the same prompt 5 times and pick the best." It's a structured pipeline where different models play different roles, with strict security boundaries between them. The Pipeline Step 1: Planning Phase When you run /fusion , up to 5 planner models are dispatched in parallel. Each planner: Receives your original prompt and context Has read-only tool access — they can search the web, read files, but never modify anything Proposes an approach (not an answer — an approach) The planners might suggest different strategies: Planner A: "Search the web for similar problems, then write a script" Planner B: "Read the existing codebase first, then modify in place" Planner C: "Break it into subtasks and use the Kanban system" Step 2: Execution Phase Your main model takes the planners' proposals and does the actual work: Full tool access (file editing, shell, web, browser, image gen, etc.) Fully visible — you watch every file edit, every command, every web search in real time Not a black box — you can intervene at any time This is the key difference from "ensemble" approaches: the main model does real work with real tools, not just text generation. Step 3: Review Phase Up to 5 reviewer models critique the draft: Read-only access — they can see what the main model produced, including generated images They check for errors, suggest improvements, flag problems Each reviewer works independently Step 4: Verdict Loop The draft is revised based on reviewer feedback: If reviewers find issues, the main model gets the feedback and revises The loop continues until reviewers approve You get the final, reviewed answer Step 5: Fusion Everything combines into one answer that has already passed independent review. Security Model The safety comes from schema-level restrictions : Role Can Read Can Write Can Execute Planners ✅ Files, web, images ❌ Nothing ❌ Nothing Main Model ✅ Everything ✅ Files ✅ Commands Reviewers ✅ Draft, files, image

DNC removal requests shouldn't take more than a few seconds to process. If your ops team is manually logging into each system, finding the number, and removing it one platform at a time, every request is an open compliance window. Here's how to close it automatically. The Problem With Manual DNC Processing A number comes in flagged for removal. Someone on the floor submits it. If you're running Convoso alongside Zoom Contact Center, Zoom Phone, and Telesero, that means logging into each system separately — find the number, remove it, move to the next platform, repeat. At multiple removal requests per week across several systems, you're looking at significant manual work each week. More importantly, every minute between the request and the removal is a minute of active compliance exposure. A TCPA violation starts at $500 per call. When the pattern is systematic — a number that should have been removed staying active across multiple campaigns — class action exposure enters the picture. The gap between when a removal is requested and when it actually completes isn't just inefficiency. It's risk that compounds with every dial attempt on a number that should be off the list. How Automated DNC Removal Works The automated version uses a Slack slash command as the intake point. An ops manager types the number into a command and hits send. The request routes immediately to a cloud service — deployed on Google Cloud Run — that fans out across every active system in parallel. Not sequentially. Simultaneously. In a contact center running multiple Convoso campaigns alongside Zoom Contact Center, Zoom Phone, and Telesero, a single command hits every platform in parallel. Each system processes the removal independently. Results log to cloud storage with a timestamp and each system's individual response recorded separately. A confirmation returns to the Slack channel before the manager has switched back to their next task. Wall-clock time from submission to confirmed removal across

This is a submission for the June Solstice Game Jam This installment brings a Firebase build to Midsommer Madness via Antigravity CLI. The Midsommer Madness web app is deployed to Firebase Web Hosting and the Maypole was saved! What I Built When it comes to Summar Solstace — the place to be is Sweden. It is one of the highlights of the calendar. This project aimed to recreate some of the mystique around the event- just in time for some fresh surestromming! Now you can get it with Firebase enhancements! FireBase Console The full project was imported to the Firebase Console: Just show me the Code!!! GitHub Repo is here: GitHub - xbill9/midsommer-firebase Midsommer Madness with Firebase So how can we use Firebase to enhance the project? Github and Skills! The GitHub repository has been successfully linked to your Firebase project midsommer-madness . ### What was configured: 1. GitHub Secrets: A service account ( github-action-1273534909 ) with Firebase Hosting admin permissions was created, and its credentials were uploaded to your GitHub repository secrets as FIREBASE_SERVICE_ACCOUNT_MIDSOMMER_MADNESS . 2. GitHub Actions Workflows: Two workflow files were generated and pushed to your GitHub repository: • firebase-hosting-pull-request.yml: Deploys a preview channel of the game whenever a PR is created against the master branch. • firebase-hosting-merge.yml: Automatically deploys the latest version to the live Firebase Hosting site whenever a PR is merged (or a commit is pushed) to the master branch. 3. Agent Skills: Installed Firebase Agent Skills in the repository to make it easier for agents to help you with Firebase configurations in the future. > /skills ⎿ Exited /skills command What else? > how is firebase enhancing the project ● Read(/home/xbill/midsommer-firebase/lib/main.dart) (ctrl+o to expand) Firebase enhances the Midsommer Madness project in four primary ways, turning it from a simple local game into a connected, production-ready mobile application: ### 1.

Build-in-public. This is the real architecture behind running ~50 local AI agents on 6GB of VRAM — one GPU lock, an eviction watchdog, a resource governor, and a model router. Originally posted on my blog. The question I get most often is some version of "there's no way you run that many agents on a 6GB laptop GPU." The honest answer: not the way you're picturing it. I don't run 50 models at once. I run one model at a time, very deliberately — and most of the engineering is about scheduling, not inference. Here's the actual architecture. The hard constraint: 6GB of VRAM A single consumer GPU with 6GB of VRAM holds roughly one 7B-parameter model at a usable quantization. Two at once? It thrashes — the GPU starts swapping, latency explodes, and eventually a driver out-of-memory can take the whole machine down. I've had the desktop freeze from exactly that. So the first design rule wrote itself: only one heavy model is allowed on the GPU at any moment. That sounds limiting. It isn't — because almost nothing I run is latency-sensitive. A blog post that publishes at 7am doesn't care if it was generated at 6:52 or 6:58. Once you accept that your AI workforce is a batch system, not a chat window, the whole problem changes shape. A lock, not a crowd Every agent that needs the GPU has to take a lock first. It's a simple file-based queue with: FIFO ordering PID-based ownership Stale-lock detection, so a crashed job can't wedge the line forever If an agent can't get the lock within its timeout, it skips gracefully and tries again on its next scheduled run instead of piling up. So at 50 agents, what's really happening is: dozens of cron-scheduled Python workers wake up throughout the day, and the ones that need the model form an orderly line for it. The fleet is huge; the GPU contention is always exactly one. That's the trick. It's less "50 models" and more "50 employees sharing one very busy workstation, politely." Eviction and a VRAM watchdog Even with the lock, idle models l

On June 12, 2026, enterprise developers using the Codex API started seeing an unfamiliar response header: X-Model-Version: kindle-alpha . It appeared on a subset of requests for roughly 18 hours, then vanished. That's the release candidate for GPT-5.6 — OpenAI's next flagship model — leaking through the staging layer. OpenAI's Chief Scientist publicly called the upcoming release "a meaningful leap" the following day. By OpenAI's historically understated communications standards, that's loud. This post covers what the backend traces, developer reports, and Polymarket odds (currently ~80% for a pre-June-30 launch) actually tell you about the model — and what to do before it drops. How the Leak Surfaced Three separate sources converged in the 72 hours after the June 12 header incident. First, developers with ChatGPT Pro OAuth access reported hitting context windows significantly beyond GPT-5.5's supported limit. At least four documented cases logged successful 1.5M-token completions before the backend silently downgraded them to the production model. Second, the Codex enterprise API logs — accessible with full response header exposure enabled — confirmed the kindle-alpha codename across US-east-1 and us-west-2 endpoints. Third, the Polymarket market for "GPT-5.6 public release before July 1, 2026" moved from 61% to 80%+ within 48 hours of the header reports circulating on developer forums. None of this is from OpenAI's press office. No model card, no official benchmark numbers, no pricing. The specifics below are high-confidence inference from multiple corroborating signals — not official spec. Treat it accordingly when making production decisions. The Architecture Shift: Agentic-First, Not Just Smarter GPT-5.5 was trained as a reasoning model with agent capabilities added on top. GPT-5.6 is reportedly designed in the opposite order. The primary optimization target during training was not MMLU or GPQA benchmark scores — it was token efficiency on long-horizon agentic t

The Problem Most AI assistants give you one model's answer. If it's wrong, you catch it or you don't. If you use a cheap model, quality drops. If you use a frontier model, you pay frontier prices for everything — even a simple file rename. What is Agentic Fusion? When you run /fusion , a panel of models collaborates on your task: Planners (up to 5): Read-only models that research and propose routes in parallel. They figure out the best approach but can't touch your files or run commands. Main model : Your chosen model does the actual work — full tool access, fully visible. You watch every step. Not a black box. Reviewers (up to 5): Read-only models that critique the draft. They can see images the main model generated. They check for errors, suggest fixes, flag issues. Verdict loop : The draft is revised until reviewers approve. The answer you get has already passed independent review. Fusion : Everything combines into one reviewed, approved answer. The quality comes from synthesis — not from running the same job 5 times. Cheap open models combine into something that rivals a frontier model at a fraction of the cost. Safety by Construction Planners and reviewers are read-only at the schema level. They can research and critique, but they can never touch your files or execute commands. Only your main model has tool access, and you watch it work live. Beyond Fusion Clioloop is also: Self-improving : Keeps MEMORY.md and USER.md , updated automatically Autonomous : Set a standing goal with /goal and it loops until done Everywhere : Terminal, desktop app, web dashboard, Telegram, Slack, Discord, WhatsApp Multi-agent Kanban : Break big work into tasks with worker agents Tools : File editing, shell, web search, browser, image/video gen, TTS, MCP Scheduled jobs : Run on cron for automated workflows Open-source : Self-host everything, own your data The Omni Loop Portal One OAuth login gives you access to 300+ models. No API keys. An OpenAI-compatible proxy means any tool works

I built a UI framework named Domphy because I could not learn React although I tried many times. I mean I could not understand React code which is hidden behind multiple layers, especially when some of them use React ecosystem libs. Maybe I am an architect turned developer, so I had no foundation of programming, or I expected something clear and clean. I just think that UI should be simple — HTML and JS are enough and just need some way to make it stateful instead of making it more complicated.

Logging has a habit of ending up in the places you care about most. It starts as a few lines for visibility. Then those lines appear in request handling, market-data processing, matching loops, telemetry pipelines, and other code where predictable latency matters. At that point, a log statement is no longer just observability. It is work running on the same thread you are trying to keep fast. A line like this can look harmless: LOG_INFO ( logger , "order_id={} price={}" , order_id , price ); The important question is what happens before the caller continues . Does it evaluate expensive arguments? Format text? Copy buffers? Allocate? Contend with other producer threads? Wait for queue space? For many applications, those costs are acceptable. For latency-sensitive systems, they are part of the latency budget . spdlog is one of the best-known C++ logging libraries and a strong general-purpose choice. It is mature, easy to use, and has a broad feature set. Quill was designed for a narrower problem: How little work can a C++ logger leave on the caller thread while still producing rich, human-readable logs? That is the lens for this comparison. The interesting difference is not which library has more features. It is where each library chooses to spend work. At a Glance Area spdlog async Quill User-message formatting Producer thread Backend thread Producer handoff Shared thread-pool queue Per-thread SPSC queue Arguments for runtime-disabled levels Evaluated if the level was not compiled out Skipped by the macro-level runtime check Native synchronous mode Yes No Backend workers Configurable thread pool Single backend worker Primary focus General-purpose flexibility Low producer-side latency These differences do not make one library universally better. They make each library better suited to different workloads. Async Logging Is Not One Design "Async logging" often means "file I/O happens on another thread." That is useful, but it is not enough to describe the cost paid by t

Stop Asking 'Is GAI Here' — Ask 'At What Layer' The GAI debate has a structural problem. Someone says "passing this benchmark means GAI." A model passes it. Then they say "that benchmark wasn't hard enough." The goalpost moves. Someone says "passing the Turing test means GAI." Models pass it. Then they say "the Turing test is too easy." The goalpost moves again. Someone says "inventing new mathematics means GAI." Models do it. Then they say "that's just pattern matching in disguise." Goalpost moves. This isn't bad faith. It's a missing layer definition. We never agreed on what "general" means. Without that, every achievement gets reclassified as "not really general." I've been working on a framework that might fix this. It started as a capability map. Then I realized: this isn't just a map. It's a GAI maturity model. The Five Layers Layer Name Definition L0 Embodied Perceive and operate in the physical world L1 Application Complete single-domain tasks using tools L2 Engineering Build and maintain systems L3 Meta-Domain Abstract and transfer between unrelated domains L4 Meta-Cognition Perceive and control your own thinking process The rule: layers cannot be skipped. It's a maturity sequence, not a checklist. This immediately explains the goalpost problem: some people define GAI as L1. Others define it as L4. They're using different layers for the same word. What About Models Without Bodies? L0 requires embodiment. Text-only models don't have bodies. The cleanest answer: LLMs have no L0. They start at L1 — cognition without embodiment. This isn't a defect. It's an architectural difference. Humans build up from L0 (a baby senses the world before understanding it). LLMs start at L1 (they understand the world directly, skipping physical experience). The result: humans can "feel" when something is wrong — that's L0 feeding signals up to L4. LLMs don't have this channel. The framework forced me to face something uncomfortable: human intelligence cannot exist without a body

Crypto Clipper spreads over USB and communicates over Tor.