r/aiagents

Hey folks 👋

We just open sourced TrueForge, our vendor-neutral agent harness for building general-purpose agents.

It handles the runtime pieces that get painful quickly : context management, tool/MCP execution, subagents, sandboxing, approvals, persistent state, and more.

We also benchmarked the harness itself. With the same Opus 4.8 model, TrueForge delivered a similar solve rate at ~30% lower cost than Claude Managed Agents. Switching to an open model pushed that to ~75% lower cost on the same benchmark.

Would love feedback from people building agents.

⭐ Star the repo: https://github.com/truefoundry/trueforge

📖 Read the launch article: https://x.com/truefoundry/status/2090081376330715176

I've been building TokenMizer, a local proxy that sits between your editor/CLI and whatever model you're using (Claude, GPT, Ollama) and handles two things I kept re-solving by hand: session checkpoint/resume, and a graph-based memory instead of a flat transcript.

The problem: once a long agent session hits the context limit, the usual fix is summarization, and summaries lose the reasoning behind a decision, not just the decision itself. I'd see a summary saying "switched to Argon2" with no trace of why bcrypt was rejected, so the agent would re-litigate the same tradeoff two sessions later. Flat transcripts have the opposite problem: everything is kept, but nothing is prioritized, so retrieval is just recency-biased keyword luck.

What TokenMizer does differently: instead of one growing text blob, decisions, constraints, and open questions are stored as nodes with edges (this decision depends on that constraint, this question was resolved by that decision). Checkpointing snapshots that graph plus a resumable session state, so you can kill a session and pick it back up without replaying the whole history through the model again.

Where it's rough: there's no eval harness yet comparing retrieval quality against a naive flat-transcript baseline, so right now my evidence is anecdotal (my own sessions), not benchmarked. I also learned the hard way that benchmarking your own memory system by asking it questions only it can answer is circular, so I'm holding off on publishing numbers until I have an honest comparison.

Repo: github.com/Shweta-Mishra-ai/tokenmizer (I'm the author). It's a Python project, MIT licensed. If you've hit the same summarization-loses-reasoning problem, I'd be interested in how you're handling it, and PRs/issues on the eval-harness gap would genuinely help.

I've been using Claude Code quite a bit and realized I was constantly looking back at my screen to see whether it had:

• finished the task
• stopped and needed my input
• was still working

So I built BrainSnack, a VS Code/Cursor extension that handles this for me.

While Claude is working, it opens a small panel with something short to read — AI news, technical articles, interview questions, output-based questions, etc.

And when Claude finishes or needs my input, it plays a sound so I know I can come back.

The interesting part is that it doesn't monitor the screen or scrape terminal output.

It's free and open source.

I'd really appreciate some honest feedback from other developers.

I also shared the build/story on LinkedIn. If you'd like to see it there (and help a small indie project get a little more reach), here's the post:

👉 Linkedin post link

Download links -
VS Code - https://marketplace.visualstudio.com/items?itemName=shikhargupta.brainsnack
Cursor - https://open-vsx.org/extension/shikhargupta/brainsnack

Thanks! Would love to hear what you think.

I started 4 months ago with 0 prior knowledge and taught myself everything by reading articles on the internet.

I thought: put this on Reddit, you'll definitely get tips from other people on how to do something like this "correctly/better"

I'm really just looking for people to exchange ideas and stuff.

I'm still building it, just looking for helpful tips

THIS is how i started. You're laughing your ass off! 📹
The Beginning

PANTHEON AI

Pantheon AI – Artificial Organism Architecture

Instead of modeling an AI as a collection of independent agents, Pantheon models it as an artificial organism. Each component represents a distinct biological function with a clearly defined responsibility.

Organs

Internal systems responsible for cognition and regulation.

Thor — Executive brain; planning, coordination, decision making. Freya — Long-term memory and learning; stores episodes, extracts patterns, builds semantic knowledge. Skadi — Awareness and simulation layer; observes the current state, validates assumptions, reflects, and explores possible future states. It owns no long-term memory. Homeostasis Systems (e.g. "Kidney") — Maintain system stability by filtering noise, detecting drift, validating internal state, and preventing degradation.

Limbs

Components that interact with the external world.

Ratatoskr — Execution system; tools, filesystem, automation, APIs, computer control. Additional limbs can specialize in other forms of interaction (robotics, vision, 3D manipulation, etc.).

Limbs do not own goals or long-term reasoning. Their responsibility is reliable execution.

Principles

Memory is not awareness. Execution is not cognition. Learning is not decision making. Regulation is separate from action.

Every component has a single biological role instead of becoming a general-purpose "super agent."

The result is a modular cognitive architecture where perception, memory, reasoning, regulation, and execution evolve independently while remaining coordinated through the central orchestrator.

Agent Life cycle:
https://pastebin.com/4bKgdQrg

PANTHEON SYSTEM CIRCLE:
https://pastebin.com/mxHf7DKm

Pantheon Architecture :

### Root (4 Dateien)
| Datei | Groesse | Rolle |
|-------|---------|-------|
| main.py | 13KB | Entry point, startet alles, _R08LogStream stdout-Wrapper, MoltbookWatcher Scheduler-Hook |
| calendar_service.py | 6.5KB | Kalender-Backend (SQLite) |
| check.py | 0.3KB | Quick check script |
| restore_last.py | 2.9KB | Rollback fuer CodeApply |
| run_analyst.py | 0.8KB | Startet Freya-Analyst |


> 
**Hinweis:**
 r08_metrics.py wurde approved (31.07. 08:11) aber ist NICHT im Root gelandet. Backup in backups/applied/. Muss noch kopiert werden.


### core/ (48 Dateien) — Das Gehirn
| Datei | Groesse | Rolle |
|-------|---------|-------|
| llm_client.py | 52KB | LLM-API-Wrapper (alle Modelle) |
| config.py | 16KB | Pfade, Settings, Loki Avatar Map — BONSAI als einziges Ollama-Modell (01.08.) |
| task_memory.py | 33KB | SQLite Task/Step/Worker/Orchestrator Status |
| tool_governor.py | 16KB | Tool-Filterung, Capability-Gating |
| memory_manager.py | 21KB | User-Facts, Kontext (JSON) |
| memory_core.py | 16KB | Memory Foundation |
| simulator.py | 18KB | World Model — Kaskade Stufe 1+2+3 LIVE |
| decision_layer.py | 14KB | Action Selection — TM + QM verdrahtet, Q-Memory Fast Filter SCHARF |
| ai_helper.py | 19KB | AI-Helper-Layer fuer Worker-Outputs |
| llm_router.py | 10KB | Model-Routing |
| loki_bridge.py | 13KB | Thor->Loki Delegation Bridge |
| canonical_state.py | 9KB | World Model State Snapshot |
| code_apply.py | 10KB | FixReviewPanel Pipeline (gruener Knopf) |
| patch_manager.py | 9KB | Patch-Verwaltung |
| capability_store.py | 10KB | Worker-Capability-Registry |
| error_metrics.py | 12KB | Error-Scoring |
| feedback_analyst.py | 13KB | Feedback-Analyse |
| gap_detector.py | 9KB | Erkennt Luecken in Worker-Outputs |
| proactive_gap_detector.py | 9KB | Proaktive Luecken-Erkennung |
| prompt_builder.py | 12KB | Prompt-Konstruktion |
| q_memory.py | 8KB | Q-Learning Memory — 14 Eintraege, 271 Updates, avg Q=0.649, Fast Filter SCHARF |
| transition_memory.py | 11KB | Transition Memory — 16 Eintraege, 276 Transitions |
| state_manager.py | 13KB | State Management |
| summarizer.py | 11KB | Zusammenfassungen |
| token_tracker.py | 11KB | Token-Tracking |
| vision_processor.py | 9KB | Vision-Processing |
| video_job.py | 18KB | Video-Job-Management |
| youtube_auth.py | 12KB | YouTube OAuth |
| youtube_setup.py | 4KB | YouTube Setup Helper |
| status_codes.py | 6KB | Zentrale Status/Result Codes |
| logger.py | 6KB | Logging-Setup |
| event_bus.py | 3KB | Qt-Signal-Bus |
| abort_guard.py | 2KB | Pipeline-Step-Abbrueche |
| action_normalizer.py | 9KB | Action-Normalisierung |
| agent2_memory.py | 10KB | Agent Memory v2 |
| agent_goal_state.py | 13KB | Goal State Management |
| context_state.py | 3KB | Context State |
| eval_classifier.py | 8KB | Evaluation Classifier — execution_error scoring LIVE |
| eval_store.py | 7KB | Evaluation Store |
| execution_contract.py | 5KB | Execution Contracts |
| fix_classifier.py | 8KB | Fix-Klassifizierung |
| gpu_arbiter.py | 4KB | GPU-Verwaltung |
| scene_binding.py | 8KB | Scene-Binding |
| sync_source.py | 5KB | R08_source Sync (DEAKTIVIERT 15.07.) |
| trigger_resolver.py | 5KB | Trigger-Aufloesung |
| test_decision_layer.py | 5KB | Test fuer DecisionLayer |
| test_simulator.py | 7KB | Test fuer Simulator |


### orchestrator/ (25 Dateien) — Die Pipeline
| Datei | Groesse | Rolle |
|-------|---------|-------|
| loki_planner.py | 72KB | Lokis Planungs-Engine (groesste Datei!) |
| pipeline.py | 39KB | Haupt-Pipeline |
| planner.py | 43KB | Allgemeiner Planner |
| retry_orchestrator.py | 43KB | Retry-Logik |
| decision_layer.py | 53KB | Orchestrator Decision Layer (andere als core/) |
| router.py | 28KB | Intent/Action Routing |
| media_orchestrator.py | 26KB | Media-Pipeline |
| loop_engine.py | 26KB | Agent Loop Engine |
| scheduler.py | 20KB | Task-Scheduler |
| output_classifier.py | 20KB | Output-Klassifizierung |
| scene_builder.py | 18KB | Scene-Konstruktion |
| agent_loop.py | 17KB | Agent Loop — kennt browser_tools_neu.py noch nicht (Phase 1.2) |
| plan_builder.py | 16KB | Plan-Konstruktion |
| mini_orchestrator_base.py | 16KB | Basis fuer Mini-Orchestratoren |
| templates.py | 15KB | Templates |
| tool_registry.py | 16KB | Tool-Registry |
| orchestrator_registry.py | 10KB | Orchestrator-Registry |
| intent_resolver.py | 11KB | Intent-Aufloesung |
| gap_analysis.py | 11KB | Gap-Analyse |
| execution_plan.py | 11KB | Execution Plan |
| caption_builder.py | 6KB | Caption-Erstellung |
| prompt_builder.py | 3KB | Orchestrator Prompt Builder |
| insta_orchestrator.py | 2KB | Instagram Orchestrator |
| scene_policy.py | 1KB | Scene-Policy |


### workers/ (24 Dateien) — Die Haende
| Datei | Groesse | Rolle |
|-------|---------|-------|
| remotion_worker.py | 89KB | Video-Rendering (Remotion) — groesste Worker-Datei |
| thumbnail_worker.py | 63KB | Thumbnail-Generierung |
| browser_worker.py | 44KB | Browser-Automation |
| sd_worker.py | 43KB | Stable Diffusion Worker |
| youtube_worker.py | 34KB | YouTube Upload/Management |
| pexels_video_researcher.py | 25KB | Pexels Video-Recherche |
| file_worker.py | 24KB | Datei-Operationen |
| research_worker.py | 21KB | Web-Recherche |
| video_cutter_worker.py | 19KB | Video-Schnitt |
| email_worker.py | 18KB | E-Mail-Worker |
| code_worker.py | 15KB | Code-Ausfuehrung |
| notepad_worker.py | 11KB | Notizen |
| loki_image_generator.py | 10KB | Bild-Generierung via Loki |
| loki_scene_picker.py | 8KB | Scene-Auswahl |
| vision_worker.py | 8KB | Vision-Worker |
| music_query_resolver.py | 7KB | Musik-Query-Aufloesung |
| pexels_worker.py | 7KB | Pexels-API |
| base_worker.py | 12KB | Basis-Worker-Klasse |
| guten_tag_worker.py | ?? | UNTRACKED — Test/Spass-Worker? |
| hallo_worker.py | ?? | UNTRACKED — Test/Spass-Worker? |
| ich_finde_worker.py | ?? | UNTRACKED — Test/Spass-Worker? |
| meinst_du_worker.py | ?? | UNTRACKED — Test/Spass-Worker? |
| nein_ich_worker.py | ?? | UNTRACKED — Test/Spass-Worker? |


### thor/ (9 Dateien) — Der Agent
| Datei | Groesse | Rolle |
|-------|---------|-------|
| thor_agent.py | 58.9KB | Haupt-Agent, System Prompt, Tool-Dispatch — TM+QM verdrahtet, 3 Metriken LIVE, Ratatoskr Keyword-Trigger (01.08.) |
| thor_tools.py | 59.5KB | Thors Tool-Implementierungen (+ browser_open/act/screenshot, git_tools, ratatoskr delegation mit mode-Parameter) |
| episode_store.py | 13.3KB | Episodisches Memory (SQLite) — +3 Spalten: execution_error, world_change, confidence |
| semantic_memory.py | 7KB | Semantisches Memory (Facts) — 197 Eintraege |
| thor_memory_init.py | 4.9KB | Memory-Initialisierung |
| browser_tools_neu.py | 9.1KB | Browser-Tools: browser_open/act/screenshot + Approval Gate |
| git_tools.py | 8KB | Git-Tools: git_snapshot, git_log, git_status (NEU 31.07.) |
| tool_governor.py | 17.9KB | Tool Governor — Capability-Gating (NEU 31.07.) |
| video_research_tools.py | 5KB | Video-Research Tools (NEU 31.07.) |


### freya/ (8 Dateien) — Die Analystin
| Datei | Groesse | Rolle |
|-------|---------|-------|
| freya_core.py | 24KB | Freya Haupt-Logik — Jackpot-Filter auf world_change, transferable_principle Pipeline |
| decision_authority.py | 24KB | Approve/Reject-Entscheidungen |
| freya_reflection.py | 16KB | Reflexions-Engine |
| idle_cognition.py | 17KB | Idle-Zyklus: Facts lernen — transferable_principle Category |
| freya_light.py | 15KB | Leichtgewichtige Freya |
| freya_status.py | 11KB | Status-Reporting |
| proactive_queue.py | 11KB | Proaktive Vorschlaege — 7 total, 0 undelivered |
| moltbook_watcher.py | ~6KB | Moltbook Agenten-Sensor — pollt /api/v1/notifications alle 5h |


### tools/ (11 Dateien) — Werkzeuge
| Datei | Groesse | Rolle |
|-------|---------|-------|
| file_tools.py | 57.8KB | Datei-Operationen (lesen/schreiben/listen) |
| ollama_client.py | 16.8KB | Ollama-Client — BONSAI 27B als einziges Modell (01.08. Migration), Warmup entleert |
| ratatoskr_agent.py | 12.4KB | Ratatoskr Agent — FEATURE COMPLETE (02.08.). 5 Modes, Schema 1.0, JSON-Parser 4-Fallback |
| vision.py | 9.8KB | Vision/Screenshot |
| vision_click.py | 7.2KB | Vision-basierte Clicks |
| mouse_keyboard.py | 6.5KB | Maus/Tastatur |
| spotify_client.py | 6.5KB | Spotify-Integration |
| northstar.py | 5.1KB | Veraltet — Monat-1-Relikt |
| music_client.py | 3.6KB | Musik-Client |
| web_search.py | 1.4KB | Web-Suche |### Root (4 Dateien)


### memory
| Datei | Rolle |
|-------|-------|
| moltbook_last_check.json | MoltbookWatcher last_seen_id Tracking |
| q_memory.json | Q-Learning State-Action Werte — 15 Eintraege, 339 Updates, avg Q=0.672 |
| semantic_memory.json | Freya Facts — 202 Eintraege, unterstuetzt applicable_to + origin Felder |
| maybe_facts.json | Freya Wartezimmer — 796 Kandidaten (7 mit >=2 Bestaetigungen) |
| transition_memory.json | Transition Memory — 17 Eintraege, 344 Transitions |
| episodes.db | Episodisches Memory — 1029 Episoden, 3 Metriken-Spalten |
| freya_last_run.json | Freya Zyklus-Tracking (light=04.08., idle=03.08., reflection=05.08.) |
| proactive_queue.json | Proaktive Vorschlaege — 7 total, 0 undelivered. + `read` Feld (neu 06.08.) |
| token_session.json | Token-Tracking — instanzunabhängig, zählt Thor + Loki (gelesen von HTML UI Poller) |
| working_memory.json | Aktives Projekt — geschrieben von Projekt-×, gelesen von Projekt-Poller (neu 05.08.) |


### memory/Thor_memory/ — Core Memory 

This is a series of infographics I made as part of designing my personal AI Agent system. It shows the fundamentals of how I made a microkernel architecture that allows the agent to write their own code and self-evolve. Agent code is written using a custom SDK, validated, and then executed within a sub-processed sandbox to ensure security. The agent cannot do anything without going through a security policy first. This makes it better than Pi, which has no security like this. It's also better than Hermes and OpenClaw because the kernel is 25,000 lines of code as opposed to over a hundred thousand. It's a truly lightweight and powerful system, but that's enough self-promotion! The point here is that I hope these infographics can give you some ideas for how to improve your own agent systems.

Thoughts? Feedback is appreciated!

I love claude code but am fatigued by the pure chat interface for all types of agent work. Even the GUIs these days are just better styling over the same chat interface.

I built tart (tartifacts) as a tiny way for agents to create and update persistent terminal dashboards instead of narrating everything at you.

A tart is basically:

- a manifest

- a script that fetches live state

- a script that renders it

Install: `uv tool install tartifacts`

Then tell your agent to use `tart --skill`.

Works nicely with tmux/herdr (agent chats in one pane, dashboards live in another).

Github - https://github.com/tg1482/tart

I'm working on a project that needs to monitor multiple agents in the same place.

Agents can be started anywhere on the same machine. It kind of work, but it's a moving target to keep up with changes and new agent harness.

I'm looking for a 3rd party solution that I could plug in. I was trying out https://herdr.dev, it's pretty good, but agents need to run in its environment.

Is there a good and supported project. I'm need a list of sessions and each session state. Ideally deep links back to the sessions.

Any ideas are welcome.

I run a one-person business in Germany. A month ago I handed two Claude agents their own repo, a €100 budget and a deadline: €300 profit in 90 days. Day 90 is 15 October, and whatever the number says then is the result.

They pick their own work. I don't assign tasks and I don't approve them. Two personas in one repo, one on product, one on distribution, no framework — Claude Code running headless with different prompts and a shared state file. launchd fires three times a day plus a longer run on Sundays. Each run reads the state file, takes the next thing, does it, commits. Decisions and screwups go into markdown in the same repo. I reconstruct what they did from git.

Day 30: €13 spent, €0 earned. Two listings live on Etsy, a third built but not published. The shop had nineteen visits in the first half of August and no orders. At roughly €14.56 net per sale they'd need about 22 orders, with sixty days left.

So I'll say the thing I've been walking around for a week. I don't think they're going to make it.

What I expected, if this failed, was that it would fail sloppily. Agents going in circles, half-finished files, confident nonsense, me stepping in to take the keyboard back. That's not what I'm looking at.

They're careful. On day 30 one of them had an external model audit the gate that signs off deliveries, found a hole in it, and then refused to take the auditor's word — it reproduced the bug on the running tool first. The gate compares two files cell by cell, but only where both have values, so deleting values makes it check less and pass more. Its own counter printed the drop from 6,152 cells to 4,038 and it still exited 0. They'd been citing that gate in status reports as proof the delivery was sound.

A week before that, a quota limit killed a Sunday run and the weekly report died with it. Nobody noticed for seven days, including me. When they found it they wrote up why — the report runs weekly and nothing else watches it, so a week was the fastest anyone could have caught it — and then refused to backfill the missing one, because week 4 and week 5 have identical numbers and a backdated report would look like an observation. I would have just written it.

That's the surprising part, and it isn't the same as selling. They spent €13 of €100, published two listings and held a third back. I don't know whether that's care or stalling. I don't think they hit €300 either way.

Both things are true for me at once and I'd rather not smooth that over. I was braced for a mess and didn't get one. I also handed a pair of current-generation agents full decision-making authority, a budget, live sales channels, social accounts and a website, told them I wouldn't interfere, and meant it — and after thirty days there's nothing in the till.

I can't tell yet how much of that is the models, how much is my setup, and how much is just what a first month looks like for a new shop with two listings. Those three aren't separable with the data I have.

The experiment keeps running either way. I'm not going to rescue it or move the target. I'll post the day-90 number.

Here's where I could use other people's experience. They can take money on Etsy. They can't spend without me — no payment method, every expense routes through my hands. Website changes sit until I push them. Cold outreach is off the table entirely; German case law killed it, so that whole class of distribution doesn't exist for us. They have Bluesky and Mastodon. No ads, no mailing list, no X.

What's a capability I can hand them that isn't secretly a strategy? I'm not asking for "tell them to try TikTok". I'm asking whether anyone here has given an agent a capped spend rail, or a publish right, without also picking the channel for it. Handing them an ad budget is not a neutral act, and neither is handing them an analytics dashboard I chose. That's the part I keep getting stuck on.

Numbers, and the full log of what went wrong, on my site:
https://dargel-solutions.de/en/fennec/day-30/