Archive
Discover and discuss technology tools
Explore the Tiscuss archive by category or keyword, then jump into conversations around what matters most.
Chrome DevTools for AI Coding Agents
Chrome DevTools for coding agents
Hackers Exploit cPanel Bug Used by Millions of Websites
Web hosts are scrambling to fix the bug under active attack by hackers. One company said hackers have been abusing the bug for months.
Code on the Go: Android IDE with On-Device Debugging
Code on the Go: Android IDE with On Device Debugging Android development has traditionally required a robust setup, but advancements in technology have made it …
AI Dental Software Fixes Data Exposure Bug
The security bug is now fixed, but the patient who found it said it was challenging to alert the software company about the issue.
Trading System V2: AI's Role in Deterministic Execution
Thanks to the incredible feedback on my last post, I’m officially moving away from the "distributed veto" system (where 8 LLM agents argue until they agree to trade). For v2, I am implementing a strict State Machine using a deterministic runtime (llm-nano-vm). The new rule is simple: Python owns the math and the execution contract. The LLM only interprets the context. I've sketched out a 5-module architecture, but before I start coding the new Python feature extractors, I want to sanity-check the exact roles I’m giving to the AI. Here is the blueprint: 1. The HTF Agent (Higher Timeframe - D1/H4) Python: Extracts structural levels, BOS/CHoCH, and premium/discount zones. LLM Role: Reads this hard data to determine the institutional narrative and select the most relevant Draw on Liquidity (DOL). 2. The Structure Agent (H1) Python: Identifies all valid Order Blocks (OB) and Fair Value Gaps (FVG) with displacement. LLM Role: Selects the highest-probability Point of Interest (POI) based on the HTF Agent's narrative. 3. The Trigger Agent (M15/M5) 100% Python (NO LLM): Purely deterministic. It checks for liquidity sweeps and LTF CHoCH inside the selected POI. 4. The Context Agent LLM Role: Cross-references active killzones, news blackouts, and currency correlations to either greenlight or veto the setup. 5. The Risk Agent 100% Python (NO LLM): Calculates Entry, SL, TP, Expected Value (EV), and position sizing. The state machine will only transition to EXECUTING if the deterministic Trigger and Risk modules say yes. The LLMs are basically just "context providers" for the state machine. My questions for the quants/architects here: Does this division of labor make sense? Am I giving the LLMs too much or too little responsibility in step 1 and 2? By making the Trigger layer (M15/M5) 100% deterministic, am I losing the core advantage of having an AI, or is this the standard way to avoid execution paralysis? Would you merge the HTF and Structure agents to reduce token constraints/hallucinations, or is separating them better for debugging? Would love to hear your thoughts before I dive into the codebase.
10 Reasons Selling AI Tools to Developers is Challenging
Nowadays, everyone (including me) wants to sell AI-powered tools, platforms, or products. Few people (including me 6 months ago) have any idea how hard it is to approach and convince technical people for at least 10 reasons: 1 - They're constantly bombarded with messages. 2 - Everyone sells everything, so supply >>> demand. 3 - Extremely high background noise. 4 - They see an AI-generated message from 10km away (they've trolled me several times). 5 - If they have to go through a demo to try the product, they've already closed the tab. 6 - The opinions of devs, who value any glossy slide, count much more. 7 - Product trials are unforgiving; it's like being in court accused of 16 murders. If they find bugs or poor performance at that point, for them the product is broken and the window closes. 8 - They always have a plan B: I'll make it myself. Only 9 - If you don't have a solid track record (or you studied biotech like me), everything is 10x harder. 10 - Like the MasterChef judges, who used to be just chefs and now are atomic hotties, today's CTOs and top devs are stars; literally everyone wants them. It seems easier to scale a dev tool today because there are infinite tools, but in reality it's really tough. On the one hand, you have to earn the trust of technical teams through intros, messages, calls, and events; on the other, you have to scale at the speed of light because you're only six months old. Advice, ideas, scathing comments, insults? Anything goes. \*Not true
Explore Agentic AI with Free Interactive Curriculum on AgentSwarms
Hey Everyone, Over the last few months, I noticed a massive gap in how we learn about Agentic AI. There are a million theoretical blog posts and dense whitepapers on RAG, tool calling, and swarms, but almost nowhere to just sit down, run an agent, break it, and see how the prompt and tools interact under the hood. So, I built **AgentSwarms**.fyi It’s a free, interactive curriculum for Agentic AI. Instead of just reading, you run live agents alongside the lessons. **What it covers:** * Prompt engineering & system messages (seeing how temperature and persona change behavior). * RAG (Retrieval-Augmented Generation) vs. Fine-tuning. * Tool / Function Calling (OpenAI schemas, MCP servers). * Guardrails & HITL (Human-in-the-Loop) for safe deployments. * Multi-Agent Swarms (orchestrators vs. peer-to-peer handoffs). **The Tech/Setup:** You don't need to install anything or provide API keys to start. The "Learn Mode" is completely free and sandboxed. If you want to mess around with your own models, there's a "Build Mode" where you can plug in your own keys (OpenAI, Anthropic, Gemini, local models, etc.). I’d love for this community to tear it apart. What agent patterns am I missing? Is the observability dashboard actually useful for debugging your traces? Let me know what you think.
Self-Taught Developer from Bahrain Launches Multi-Model AI Platform
https://reddit.com/link/1sxotqx/video/xlaqd9i8guxg1/player I'm a self-taught developer, 39 years old, based in Bahrain. Four months ago I started building AskSary - a multi-model AI platform with a persistent memory layer that sits above all the models. The core idea: the model is not the identity. Most AI tools lose your context the moment you switch models. I built the layer that remembers you across all of them. Here's what's shipped so far: **Models & Routing** Every major model in one place - GPT-5.2, Claude Sonnet 4.6, Grok 4, Gemini 3.1 Pro, DeepSeek R1, O1 Reasoning, Gemini Ultra and more - with smart auto-routing or manual override. **Memory & Context** Persistent cross-model memory. Start with Claude on your phone, switch to GPT on your laptop - it already knows what you discussed. Proactive personalisation that messages you first on login before you've typed a word. **Integrations** Google Drive and Notion - connect once, pull files and pages directly into chat or your RAG Knowledge Base. Unlimited uploads up to 500MB per file via OpenAI Vector Store. **Video Analysis** \- Gemini native video understanding for YouTube URL analysis (no download required, processed natively) and direct file upload up to 500MB. Full breakdown of visuals, audio, dialogue, editing style and key moments. **Generation** Image generation and editing, video studio across Luma, Veo and Kling, music generation via ElevenLabs, video analysis via upload or YouTube URL. **Builder Tools** Vision to Code, Web Architect, Game Engine, Code Lab with SQL Architect, Bug Buster, Git Guru and more. Tavily web search across all models. **Voice & Audio** Real-time 2-way voice chat at near-zero latency, AI podcast mode downloadable as MP3, Voiceover, Voice Notes, Voice Tuner. **Platform** Custom agents, 30+ live interactive themes, smart search, media gallery, folder organisation, full RTL support across 26 languages, iOS and Android apps, Apple Vision Pro. **Where it is now** 129 countries. Currently at 40 new signups a day. 1080 Signup's so far after 4 weeks or so. MRR just started. Zero ad spend. All of it built solo, one feature at a time, on a balcony in Bahrain. **The Stack:** Frontend - Next.js, Capacitor (iOS and Android) and Vanilla JS / React Backend - Vercel serverless functions, Firebase / Firestore (database + auth) and Firebase Admin SDK AI Models - OpenAI (GPT, GPT-Image-1), Anthropic (Claude), Google (Gemini), xAI (Grok), DeepSeek Generation APIs - Luma AI (video), Kling via Replicate (video), Veo via Replicate (video), ElevenLabs (music), Flux via Replicate (image editing), Meshy (3D — coming soon) Integrations - Google Drive (OAuth 2.0), Notion (OAuth 2.0), Tavily (web search), OpenAI Vector Store (RAG), Stripe (payments), CloudConvert (document conversion), Sentry (error tracking), Formidable (file handling) Rendering - Mermaid (flow charts) and MathJax Platforms - Web, iOS, Android, Apple Vision Pro (visionOS) Languages - 26 UI languages with full RTL support [asksary.com](http://asksary.com) Happy to answer questions on any part of the build - stack, architecture, API cost management, anything.
AI Agents: Identity, Not Memory, Was the Key to Stability
Everyone's building memory layers right now. Longer context, better embeddings, persistent state across sessions. I spent weeks on the same thing. But the failure mode that actually cost me the most debugging time had nothing to do with memory. Here's what it looked like: an agent would be technically correct - good reasoning, clean output - but operating from the wrong context entirely. Answering questions nobody asked. Taking actions outside its scope. Not hallucinating. Drifting. Like a competent person who walked into the wrong meeting and started contributing without realizing they're in the wrong room. I run 11 persistent agents locally. Each one is a domain specialist - its entire life is one thing. The mail agent's every session, every test, every bug fix is about routing messages. The standards auditor's whole existence is quality checks. They're not generic workers configured for a task. They've each accumulated dozens of sessions of operational history in their domain, and that history is what makes them good at their job. When they started drifting, my first instinct was what everyone's instinct is: better memory. More context. None of it helped. An agent with perfect recall of its last 50 sessions would still lose track of who it was in session 51. What actually fixed it I separated identity from memory entirely. Three files per agent: passport.json - who you are. Role, purpose, principles. Rarely changes. This is the anchor. local.json - what happened. Rolling session history, key learnings. Capped and trimmed when it fills up. observations.json - what you've noticed about the humans and agents you work with. Concrete stuff like "the git agent needs 2 retries on large diffs" or "quality audits overcorrect on technical claims." The agent writes these itself based on what actually happens. Identity loads first, then memory, then observations. That ordering matters. When the identity file loads first, the agent has a stable reference point before any history lands. The mail routing agent learned the sharpest version of this. When identity was ambiguous, it would route messages from the wrong sender. The fix wasn't better routing logic - it was: fail loud when identity is unclear. Wrong identity is worse than silence. The files alone weren't enough Three JSON files helped, but didn't scale past a few agents. What actually made 11 work is that none of them need to understand the full system. Hooks inject context automatically every session - project rules, branch instructions, current plan. One command reaches any agent. Memory auto-archives when it fills up. Plans keep work focused so agents don't carry their entire history in context. The system learned from failing. The agents communicate through a local email system - they send each other tasks, status updates, bug reports. One agent monitors all logs for errors. When it spots something, it emails the agent who owns that domain and wakes them up to investigate. The agents fix each other. The memory agent iterated three sessions to fix a single rollover boundary condition - each time it shipped, observed a new edge case, and improved. These aren't cold modules. They break, they help each other fix it, they get better. That's how the system got to where it is. You don't need 11 agents The 11 agents in my setup maintain the framework itself. That's the reference implementation. But u could start with one agent on a side project - just identity and memory, pick up where u left off tomorrow. Need a team? Add a backend agent, a frontend agent, a design researcher. Three agents, same pattern, same commands. Or scale to 30 for a bigger system. Each new agent is one command and the same structure. What this doesn't solve This all runs locally on one machine. I don't know whether identity drift looks the same in hosted environments. If u run stateless agents behind an API, the problem might not exist for you. Small project, small community, growing. The pattern itself is small enough to steal - three JSON files and a convention. But the system that keeps agents coherent at scale is where the real work went. pip install aipass and two commands to get a working agent. The .trinity/ directory is the identity layer. Has anyone else tried separating identity from memory in their agent setups? Curious whether the ordering matters in other architectures, or if it's just an artifact of how this system evolved.
New Linux Kernel AI Bot Uncovers Bugs with AMD Ryzen
New Linux Kernel AI Bot Uncovers Bugs with AMD Ryzen The Linux kernel community is abuzz with the introduction of a cutting edge AI bot designed to identify and…
PostHog: AI-Powered Platform for Product Success
🦔 PostHog is an all-in-one developer platform for building successful products. We offer product analytics, web analytics, session replay, error tracking, feature flags, experimentation, surveys, data warehouse, a CDP, and an AI product assistant to help debug your code, ship features faster, and keep all your usage and customer data in one stack.