Login

r/Agentic_Marketing

TokenMizer - a local proxy for session checkpoint/resume and graph memory across Claude, GPT, and Ollama
▲ 20 r/Agentic_Marketing+8 crossposts

TokenMizer - a local proxy for session checkpoint/resume and graph memory across Claude, GPT, and Ollama

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.

u/Feisty-Cranberry2902 — 10 hours ago
▲ 8 r/Agentic_Marketing+3 crossposts

I built this multiagent AI system alone in my bedroom 😂

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
u/Vivid_Ad_5069 — 13 hours ago
▲ 18 r/Agentic_Marketing+9 crossposts

AIMeter — an ultra-fast, local-first LLM API cost & token tracker for macOS

With every company struggling to cap AI cost budgets, as a developer I found it equally hard to keep track of my own API usage costs when coding with Cursor, Claude Code, or local scripts.

So I built AIMeter — an ultra-fast, local-first LLM API cost & token tracker for macOS. It transparently monitors your spend in a native menu bar widget and dashboard with zero latency overhead, keeping your prompts and keys 100% #private.

Open-source and installable in seconds via #DMG or #Homebrew!

GitHub: https://github.com/smriti-memcore/aimeter

u/thesunsetisbeautiful — 2 days ago
▲ 3 r/Agentic_Marketing

6 months ago every GEO conversation was about structured data — now 80% of the questions I get are about brand entities, and I'm not sure SEO teams can pivot fast enough

But if the play is really about brand entities now, the teams that win won't be the ones with the best schema markup. They'll be the ones who figured out how to make their brand unavoidable.

reddit.com
u/Brave_Acanthaceae863 — 4 days ago
▲ 6 r/Agentic_Marketing

Visa, Mastercard, Stripe, Google and AWS all just joined a foundation for "AI agent payments." Actual daily volume: ~$28K. What am I missing?

I went down a rabbit hole this week after seeing Cloudflare launch "Wallets for AI agents" (agents get their own spending-controlled wallets, since they can't open bank accounts or click "Sign up with Google").

The bull case is real infrastructure, not vaporware:

  • The x402 protocol (HTTP 402 "Payment Required", finally used after 27 years) moved into the Linux Foundation this July, with 40+ members: Visa, Mastercard, Amex, Stripe, Google, AWS, Shopify, Coinbase
  • Stripe shipped x402 support in February (Machine Payments)
  • Cloudflare will block mixed-use AI crawlers by default on ad-carrying pages starting Sept 15 unless AI companies pay — plus a "Monetization Gateway" so any site can charge agents per call
  • Google's AP2, OpenAI+Stripe's ACP, Mastercard Agent Pay, Visa Trusted Agent Protocol — the whole stack exists now

Then I looked at usage. Daily settlement volume on x402: about $28K. Down 93% from the Q4 2025 peak, which turned out to be mostly developer testing, wash trading and a memecoin. Chainalysis data shows sub-$1 micropayments — supposedly THE killer use case — collapsed from 46% of volume to 4%.

One number did surprise me though: the x402 Bazaar has ~4,400 buyers and only ~477 sellers. Whatever demand exists, it's starved for supply. And of 15,000+ MCP servers out there, fewer than 5% are monetized at all.

So I'm genuinely torn between two readings:

  1. This is early-internet-1995: the rails always look overbuilt before the traffic arrives
  2. This is micropayments-will-save-the-web all over again — we've buried that idea three times since the 90s

Questions for people actually building here:

  • Does anyone have an agent that actually pays for API calls / data / tools in production? What does it buy?
  • If you run an API or MCP server: would you put it behind a 402 paywall today, or is the buyer pool still too small to bother?
  • Is there any reason agent payments won't just get absorbed into credit-card rails (Stripe/Visa tokens) with crypto micropayments staying niche?
reddit.com
u/Lopsided_Scarcity979 — 6 days ago
▲ 1 r/Agentic_Marketing+1 crossposts

A thumbs-up emoji was silently breaking my sales agent. The real bug wasn't the parsing.

I run a WhatsApp sales bot. On each incoming message, it picks one of four moves: answer, ask a question, wait, or hand off to a human and pause.

The handoff is the safety valve. When it's unsure, it pages a person. Better that than fumbling a real buyer. I noticed it was firing constantly, on leads that clearly didn't need anyone, so I went into the logs expecting a bad confidence threshold.

It wasn't a threshold. It was WhatsApp. A thumbs-up reaction doesn't arrive as text. Neither do system events. My parser looked for a message, found none, and did the "safe" thing: page a human, freeze the chat. Most of the handoffs traced back to these non-text events, not to real leads. The bot was tapping out over messages that weren't messages.

The parsing fix took an afternoon. The part I keep thinking about is why it felt safe while it was quietly wrecking things.

The two ways the bot can be wrong don't cost the same. Paging a human for nothing is cheap, a few wasted seconds. Missing a hot or upset lead is expensive and usually unrecoverable. They don't complain; they just leave. My system spent all its caution on the cheap error. "When unsure, page a human" looks responsible, but it's one reflex for every kind of uncertainty, with no sense of what any mistake actually costs.

What I'm testing now is a policy that weighs the cost of each kind of mistake before it acts, running in shadow so it decides silently while I compare it against what the bot actually did.

Curious how others handle this. When your agent is uncertain, do you fall back to a human by default, or do you try to price the mistakes? And how do you catch the "safe" fallback that's actually the expensive one?

reddit.com
u/Sudden-Theme7554 — 7 days ago
▲ 16 r/Agentic_Marketing+1 crossposts

The biggest mistake I keep seeing in agentic marketing workflows: the ideas never stay connected to the work

I kept losing the thread between a marketing idea, the execution notes, the GitHub issue, and the final reporting. By the time something shipped, nobody remembered why we started it or which experiment actually mattered.

That turned into a useful lesson for me: in agentic marketing, the hard part is not generating more output, it's preserving context as the work moves from brainstorm to action. If the system breaks there, the agent can be fast but still feel disconnected.

What helped most was keeping notes, tasks, imports, and status updates in one continuous thread instead of scattering them across tools. That way the handoff from idea to execution is visible, and the reasoning behind a decision does not disappear halfway through.

I am curious how others here are handling this. Are you keeping campaign planning, AI outputs, and reporting in one place, or are you still stitching it together manually across multiple tools?

For us, the win was less about automation and more about continuity. Once the context stayed attached to the work, it became much easier to decide what to ship, what to kill, and what to iterate on.

Would love to hear what has actually worked for other founders and marketers trying to build agentic workflows without losing the original intent.

reddit.com
u/BronsonDunbar — 6 days ago
▲ 3 r/Agentic_Marketing

I'm starting to think websites won't be built for humans forever.

The more I look at where AI is heading, the more I wonder if websites will eventually become secondary.

If AI agents can research products, compare prices, read documentation, fill out forms, and even make purchases for us, brands might end up optimizing for AI agents instead of human visitors.

That feels like a much bigger shift than just "AI in marketing."

Do you think websites will always be the main destination, or are AI agents going to become the new front door to the internet?

reddit.com
u/Impossible_Truth_629 — 7 days ago
▲ 1 r/Agentic_Marketing

I think the hardest part of agentic marketing isn't autonomy — it's giving the agent the right memory

I've been thinking about agentic marketing from more of an engineering side, and one thing keeps bothering me: we talk a lot about making agents more autonomous, but not enough about giving them reliable memory.

An agent can research a customer, analyze a campaign, write a message, and trigger an action. But what happens when it interacts with that same customer again next week?

If it doesn't remember what happened before, it's not really building a relationship. It's just starting another conversation with a bigger prompt.

For me, useful agentic marketing would need to keep track of things like:

what the customer has already seen

what they ignored or responded to

previous questions or objections

their current segment or stage

what they've already been offered

contact/frequency limits

why the agent made a particular decision

what happened after that decision

And I don't think simply throwing the entire customer history into an LLM context window is the answer.

I'd rather see something closer to:

Events → State → Decision → Policy check → Action → Outcome → Updated state

That feels much closer to an actual agentic system than just giving an LLM more tools.

It also makes me wonder: should we really measure an agent by how autonomous it is, or by how well it learns from the outcomes of its previous decisions?

I'm leaning toward the second one.

Curious how others here are approaching this. Are you maintaining explicit customer/campaign state outside the model, or mostly relying on retrieval and prompts to reconstruct the context each time?

Once these systems operate for weeks or months, I think memory, state, attribution, and auditability become just as important as the model itself.

reddit.com
u/GeneralPhilosophy950 — 8 days ago
▲ 9 r/Agentic_Marketing+1 crossposts

The "Agentic Marketing" paradox: We are building autonomous growth teams, but running them like a chaotic Slack chat.

Hey everyone, thanks for the invite to the sub. Awesome to see a dedicated space for this, because agentic workflows are 100% the future of growth and distribution.But as we transition from simple automation (Zapier/Make) to true autonomous agent marketing teams, I think we are hitting a massive architectural roadblock. Right now, if you look at most agentic marketing setups, it looks like a chaotic group chat. We spin up an "SEO Research Agent", a "Copywriting Agent", and a "Distribution Agent" using frameworks like CrewAI or AutoGen. We connect them to our live WordPress sites, our HubSpot CRMs, and our social media APIs via raw python scripts or loose wrappers.Then we just pray that the copywriting agent doesn't get caught in a prompt-injection loop, or that the research agent doesn't hallucinate a broken line of code that drops our database or triggers a spam filter penalty across our entire domain. In marketing, we love the idea of "configure once, forget forever" autonomy. We want to tell a system: "Go study our competitor's backlinks, find the gaps, write the articles, and deploy the campaigns." But you cannot safely walk away from a system like that if it’s running in a shared, unprotected cloud environment with zero visual oversight. If an agent needs a human to click "approve" every 30 seconds to make sure it doesn't break anything, it's not an autonomous team it's just a very high-maintenance chatbot.

Aeon//Neon team pent the last few months trying to solve this infrastructure mess. We realized that for marketing agents to actually run headless and unsupervised, they need two things:

  1. A visual control plane (The Graph) so humans can actually see the org chart, dependencies, and boundaries of the bots at a single glance.

  2. Hardware-isolated workstations (The Seat) where every single agent executes its tools (like hitting Google Search, scraping, or updating a CRM) inside a secure, sandboxed micro-VM using the MCP standard. If the agent goes crazy, the blast radius is completely contained.

I’m curious to know how the growth hackers and marketers in this sub are scaling their setups right now.

Are you guys still babysitting every single run with manual approval loops because you don't trust the LLM with your live systems? Or are you starting to look into sandboxing and deterministic control planes? Let's chat architecture.

reddit.com
u/AeonNeon_dev — 8 days ago
▲ 2 r/Agentic_Marketing

3 AI search behaviors I noticed watching 12 people use Perplexity for the first time — none of them behave like Google users

A client asked me last week to sit with their team while they tried AI search for the first time. None of them had used Perplexity, ChatGPT search, or Gemini for anything beyond quick experiments. Twelve people, ranging from marketing managers to product folks, all reasonably tech-literate but firmly in the "I just Google things" camp.

I gave them a list of 10 work-related questions and asked them to search using Perplexity. No instructions, no tips, just "find the answer." I sat behind them and took notes.

Three things jumped out that I can't stop thinking about.

The first one is about question length. Every single person typed queries that were 2-3x longer than what they'd type into Google. Full sentences, context included, sometimes follow-up context before even getting a response. On Google they'd type "best CRM for small B2B." On Perplexity they typed things like "what's a good CRM for a 15-person B2B SaaS team that needs Salesforce integration but doesn't want to pay per contact." The queries were rich, specific, and way more revealing about intent. Nobody coached them. They just did it.

The second thing was about source links. Almost nobody clicked them. Out of 12 people and roughly 120 searches, I counted 9 total source clicks. That's under 8%. And it wasn't because they trusted the AI blindly — several people said the answer "seemed right" or "mentioned a brand they'd heard of," which was enough. They weren't verifying. They were consuming the answer as a finished product, not as a starting point for research.

The third observation messed with my head a bit. When the AI answer mentioned a brand or product, people treated it differently than when a Google result mentioned the same brand. Google results were met with skepticism — "this is probably SEO'd" or "this is an ad." AI mentions carried more weight. Three people said variations of "the AI wouldn't recommend it if it wasn't good." Whether that trust is warranted is a whole different conversation, but the baseline confidence was strikingly higher.

None of this is rigorous research. Twelve people in one session isn't going to generalize cleanly. But watching it happen in real time made me wonder how much of our GEO strategy is built on assumptions about user behavior that don't match reality. We optimize for discoverability and citation accuracy. We assume users will evaluate sources. We assume citations function as trust signals.

What if they don't? What if most users never scroll past the AI summary, never click a source, and treat the AI's brand mention as the entire decision?

I keep going back to the person who said "the AI wouldn't recommend it if it wasn't good." That's the sentence that stuck with me. That's the trust gap we're actually working with.

Twelve people isn't enough to draw conclusions. But it's enough to change the questions I'm asking. What's the behavior you keep noticing when you watch people use AI search for the first time?

reddit.com
u/Brave_Acanthaceae863 — 9 days ago
▲ 35 r/Agentic_Marketing+13 crossposts

I built SpecJudge — a CLI that reads your specs and tells you which AI model to use without overpaying

Picking an AI model to implement a project is a coin flip between two costs: too powerful and you overpay for capability you won't use; too weak and it just can't do the job.

SpecJudge reads your Spec-Driven Development artifacts and recommends the model that's right-sized for the work — not the cheapest, not the most powerful, the one that actually fits. A local model (via Ollama) judges how hard your project is, then it's crossed against a catalog of models and prices to produce a ranked podium.

It's local-first (your specs never leave your machine), MIT-licensed, and the whole model catalog is plain YAML you can edit with a PR — no Python needed to add a model or fix a price.

pip install specjudge
specjudge /path/to/your/project      # add --open for a visual matrix in your browser

Requires Python 3.11+ and Ollama with a local model.

It's an early release — I'd genuinely like to hear if the ratings match your experience, and PRs to the catalog are very welcome.

u/jokiruiz — 13 days ago
▲ 3 r/Agentic_Marketing+1 crossposts

I build AI phone receptionists that answer calls 24/7 and book appointments (n8n + Vapi)

I build AI receptionists for small service businesses — they answer calls around the clock, book appointments to a calendar, capture leads, and send confirmations. Built on n8n and Vapi, production-tested.

I have a live demo you can call and talk to (+17194679406). Ask it questions, book a test appointment.

My website is: https://qualityautomationsonn8n.com/

u/YesterdayHonest4105 — 12 days ago
▲ 1 r/Agentic_Marketing+2 crossposts

A gamified, open source AI team that finds you a job

Job hunting is a second job: same boards every evening, same CV rewritten, mostly no reply. So I built a team of AI agents to do that part. It searches, throws away what isn't worth your time, and prepares the CV and cover letter for what's actually a fit. You just decide what to send.

And it isn't a dashboard with progress bars. It's a gamified experience: you see your team at work in an office, and you can walk up to any of them and talk. Ask what they're doing, why they rated a job the way they did, tell them to change direction. They run on frontier models (Claude, Codex or Kimi), so those are real conversations. It makes the whole thing a lot less grim than staring at a spreadsheet of rejections.

It runs on your own computer, and your CV and your data stay there. There's a desktop app for Windows, macOS and Linux, so if you can install a normal program you can run this. It's free and open source. The only cost is the AI subscription it runs on.

It is not a bot that fires your CV at three hundred openings. That wastes everyone's time and burns your name with the companies you actually cared about.

Here's the part I care about most. Almost all the AI in hiring today sits on the employer's side, screening and filtering people, often without anyone reading a word they wrote. This is the same technology, put in the hands of the person looking for work and running on their own machine.

It's one person's project, so it has rough edges. If this resonates and you want to contribute, I'd be glad to have you: code, but also testing it on your own hunt and telling me where it breaks, docs, translations, design.

jobhunterteam.ai

u/Ambitious-Scholar501 — 12 days ago
▲ 6 r/Agentic_Marketing+2 crossposts

Looking for advice from people dealing with high LLM or AI API costs

Hi everyone,

I’m from Korea, and English isn’t my first language, so I used AI to help translate this post.

I’ve been experimenting with different AI tools and projects for a while. During that process, I ended up with a much larger token bill than I expected.

That experience made me think there should be a better way for people and companies to use AI without constantly worrying about costs, while still keeping the system reliable and safe.

At first, I started building something just for my own use. I added features one by one, and over time the project became much bigger than I originally planned. Eventually, I started wondering whether it could become a real business.

But I’ve run into a problem.

In Korea, I haven’t been able to find many companies that are openly talking about this issue or looking for a solution. I’m not sure whether the problem isn’t serious enough yet, or whether companies simply don’t want to share their AI cost problems publicly.

So I’d really appreciate some honest feedback from developers, engineers, founders, or anyone operating AI products in production.

  • Are AI or LLM costs a real problem for you?
  • What part of cost management is the most difficult?
  • How do you currently track costs by model, feature, customer, or request?
  • What kind of tool or service would actually be useful?
  • Have you tried solving this problem already? If so, what didn’t work?

Any practical advice or real-world experience would be very helpful. I’m still trying to understand whether this is a problem worth solving and what people actually need.

Thank you.

reddit.com
u/MutedMaintenance6420 — 14 days ago
▲ 3 r/Agentic_Marketing

Hi! I released an open-source tool today.

Marketing skill packs for agents keep multiplying, and they all focus on what the agent should write. I kept hitting the other two problems: the agent claiming things my product does not do, and the visuals looking obviously Al-generated. So I built the layer underneath and open-sourced it.

What it does:

The skill scans your repo and drafts product facts, each with a file:line reference. Nothing becomes claimable until a human confirms it, so the agent physically cannot promote its own guesses. Copy then lints against those facts: unmeasured numbers, hype vocabulary and absolute promises fail the build, and so do the tells of generated prose (the in-sentence em dash, the rule-of-three tic, formula connectives).

Cards and video render from one HTML contract. Your brand colors and fonts come from your own token files, get inlined into the page, and a real browser takes the screenshot over CDP. No diffusion pass, so the text on a card is just text: it renders intact. Video is frame-by-frame capture of a scene that is a pure function of time, and every scene must declare provenance: a coded reconstruction cannot ship labeled as a screen recording.

Install:

/plugin marketplace add cagatayuncu/marketing-machine /plugin install marketing-machine

Then say "setup" in your repo and the skill configures itself from your codebase (colors, fonts, languages, legal routes). It also installs as a Cursor rule or an AGENTS.md section if you use those, and everything works as a plain CLI without any agent.

Limits, honestly: the linter holds only mechanical rules, judgment stays in the skill prompt; it cannot produce photography; language packs exist for English and Turkish, German is partial. MIT, plain Node, no runtime

dependencies.

Repo: https://github.com/cagatayuncu/marketing-machine

I used it on itself for the launch content, including the card in this post. What would you want a marketing gate like this to catch that it does not?

reddit.com
u/cagatayuncu — 14 days ago