Archive
Discover and discuss technology tools
Explore the Tiscuss archive by category or keyword, then jump into conversations around what matters most.
Modern C++ Build Tools for Module Feature Showcased
Modern C++ Build Tools for the Module Feature The introduction of modules in C++17 and subsequent updates has revolutionized the way C++ code is managed, offeri…
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.
AutoIdeator: Free Open Source Agent Orchestration for Development
[https://github.com/akumaburn/AutoIdeator](https://github.com/akumaburn/AutoIdeator) https://preview.redd.it/rfbgg6e34dyg1.png?width=3809&format=png&auto=webp&s=e436362c48482d09025a394a5e609f67190e6dfa AutoIdeator is an autonomous development system that: 1. Takes a **final goal** — a detailed, multi-sentence description of the intended end result. Describe what the finished project should look like, do, and feel like for the user. **Do not** prescribe implementation steps, phases, milestones, technologies, or task lists — the agents handle planning. The more clearly the desired end state is described, the better convergence will be. 2. Generates improvement ideas via a rotating ensemble of specialized idea agents 3. **Scores and filters ideas** for goal alignment and quality 4. **Critiques ideas constructively** with suggested mitigations 5. **Evaluates strategic alignment** and long-term planning 6. Makes implementation decisions balancing creativity and criticism 7. Implements the plan with parallel coders 8. Reviews, fixes, and commits changes 9. **Runs QA** (build + test verification) 10. **Optimizes slow tests** to keep the suite fast 11. **Verifies goal completion** with 3-step feature inventory, per-feature checks, and auto-remediation 12. **Refactors oversized files** into smaller modules (every other cycle) 13. **Cleans up** temp files and build artifacts 14. Updates project documentation 15. **Records outcomes for learning and deduplication** 16. **Periodically synthesizes synergies** across recent work 17. **Checkpoints state** for pause/resume across restarts 18. Repeats the cycle infinitely until stopped Users can inject suggestions at any time via the Overseer agent, which takes priority over the autonomous idea generation pipeline. Note this system has been tested for some time but only in the dashboard with OpenCode/Claude Code configuration (OpenRouter mode is untested, but I welcome contributions if someone wants to use that mode and notices something is broken).
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.