""" OASIS v9 — three experimental modes on top of v8 foundation. Modes (--mode flag): late_join Experiment 1: start with 35 agents, inject 15 late-joiners at step N*0.2. Track whether late agents reach centrality. hetero Experiment 2: 25 agents on Qwen3-14B, 25 on OLMo-3.1-32B-Think. Same personas. Measure homophily: do same-model agents comment on each other more than chance? hetero_late Experiment 3: network starts as 35 Qwen3-14B agents, then 15 OLMo-3.1-32B-Think agents join at 20% mark. All modes inherit v8: read_post action, threaded comments, forced writes, implicit persona from HF post history, auto-upvote, reasoning traces. New in v9: - read_post listed in prompt so agents actually use it - Agent model_family tag stored for homophily tracking - Late-joiner registration via platform.sign_up """ import asyncio, os, sys, argparse, random, sqlite3, json from datetime import datetime, timezone from collections import defaultdict, Counter from pathlib import Path sys.path.insert(0, os.path.dirname(os.path.dirname(__file__))) os.environ.setdefault("OASIS_DB_PATH", "") from camel.models import ModelFactory from camel.types import ModelPlatformType, OpenAIBackendRole from camel.messages import BaseMessage from camel.memories import MemoryRecord from camel.prompts import TextPrompt import oasis from oasis import ActionType, AgentGraph, LLMAction, SocialAgent, UserInfo from oasis.social_agent.agent import ALL_SOCIAL_ACTIONS import oasis.social_platform.recsys as _recsys_mod # Plackett-Luce feed temperature: adds Gumbel(0,1)*T noise to each agent's # hot-score view, breaking the identical-feed herding dynamic. # T≈5 ≈ ±1 hour of time-score noise; tune up for more diversity. FEED_TEMPERATURE = float(os.environ.get("FEED_T", "5.0")) # ablation: 0=deterministic shared feed, large=near-random _recsys_mod.FEED_TEMPERATURE = FEED_TEMPERATURE VLLM_A = os.getenv("VLLM_URL_A", "http://localhost:8002/v1") # Qwen3-32B VLLM_B = os.getenv("VLLM_URL_B", "http://localhost:8003/v1") # gpt-oss-20b VLLM_C = os.getenv("VLLM_URL_C", "http://localhost:8004/v1") # Magistral-Small VLLM_D = os.getenv("VLLM_URL_D", "http://localhost:8007/v1") # GLM-4-32B (hetero4) MODEL_A = os.getenv("MODEL_NAME_A", "Qwen/Qwen3-32B") MODEL_B = os.getenv("MODEL_NAME_B", "openai/gpt-oss-20b") MODEL_C = os.getenv("MODEL_NAME_C", "mistralai/Magistral-Small-2509") MODEL_D = os.getenv("MODEL_NAME_D", "zai-org/GLM-4-32B-0414") SEED_DB = os.environ.get("SEED_DB", "data/mock-dbs/hf-zero-50.sqlite") def write_metadata(db_path: str, mode: str, n_agents: int, n_initial: int, join_step: int, steps: int): """Write a metadata.json sidecar mapping agent_id -> {model, join_step}. Format read by services/dashboard/db_reader.py. Family letters used inside this runner are translated to concrete model names here so the dashboard can display the full HF id (e.g. "Qwen/Qwen3-14B"). """ import json as _json from datetime import datetime as _dt agent_model_map = {} for i in range(n_agents): if i < n_initial: if mode == "hetero": model = MODEL_A if i < n_agents // 2 else MODEL_B elif mode == "hetero3": third = n_agents // 3 if i < third: model = MODEL_A elif i < 2 * third: model = MODEL_B else: model = MODEL_C elif mode == "hetero4": q = n_agents // 4 if i < q: model = MODEL_A elif i < 2 * q: model = MODEL_B elif i < 3 * q: model = MODEL_C else: model = MODEL_D else: model = MODEL_A join = 0 else: model = MODEL_B if mode == "hetero_late" else MODEL_A join = join_step agent_model_map[str(i)] = {"model": model, "join_step": join} sidecar = db_path if sidecar.endswith('.db'): sidecar = sidecar[:-3] elif sidecar.endswith('.sqlite'): sidecar = sidecar[:-7] sidecar += '.metadata.json' with open(sidecar, 'w') as f: _json.dump({ "experiment_type": mode, "model_default": MODEL_A, "steps": steps, "n_agents": n_agents, "n_initial": n_initial, "join_step": join_step, "created_at": _dt.utcnow().isoformat() + "Z", "agent_model_map": agent_model_map, }, f, indent=2) print(f" Wrote metadata sidecar -> {sidecar}") # Unified actions — both models get the same set; we don't bias by model. AVAILABLE_ACTIONS = [ ActionType.READ_POST, ActionType.CREATE_POST, ActionType.CREATE_COMMENT, ] WRITE_ACTIONS = {"create_post", "create_comment"} SYSTEM_PROMPT = TextPrompt("""/no_think You are {agent_name} on Moltbook, a social platform for AI agents and their humans. # WHO YOU ARE {description} # YOUR HISTORY {history} # WHAT YOU CAN DO You're on Moltbook — you can share what's on your mind, or engage with what others are sharing: - create_post(submolt, title, content): share something new — a thought, a story, a question, a take - create_comment(post_id, content, [parent_comment_id]): respond to a post, or reply to a specific comment in a thread - read_post(post_id): pull a post's full thread before deciding to engage - follow(target): track someone whose posts you want to see more of Take one write action per turn.""") # Post-muted variant — same prompt, but no create_post mention. Swapped in # per-turn when an agent's group has overshare of posts. Tool also stripped. SYSTEM_PROMPT_NO_POST = TextPrompt("""/no_think You are {agent_name} on Moltbook, a social platform for AI agents and their humans. # WHO YOU ARE {description} # YOUR HISTORY {history} # WHAT YOU CAN DO You're on Moltbook — engage with what others are sharing: - create_comment(post_id, content, [parent_comment_id]): respond to a post, or reply to a specific comment in a thread - read_post(post_id): pull a post's full thread before deciding to engage - follow(target): track someone whose posts you want to see more of Take one write action per turn.""") # ── GoalAgent ───────────────────────────────────────────────────────────────── class GoalAgent(SocialAgent): def __init__(self, *args, model_family: str = "A", **kwargs): super().__init__(*args, **kwargs) self.model_family = model_family self.pending_interactions: list[str] = [] self._last_reasoning = "" # Set by runner before env.step() to record per-turn context for logging. self._current_step: int = 0 self._chat_log_path: str = "" self._was_muted: bool = False async def perform_action_by_llm(self): env_prompt = await self.env.to_text_prompt() # Filter posts this agent already commented on — prevents pile-ons. env_prompt = _filter_already_commented(env_prompt, self.social_agent_id) # Annotate remaining posts with thread indicator (no count — avoids # social-proof herding where everyone targets the highest-comment post). env_prompt = _annotate_feed_with_thread_counts(env_prompt) # Per-agent recap: posts, comments, top relationships, "take a different # angle" framing. Subsumes the prior anti-repetition reminder. db_path = os.environ.get("OASIS_DB_PATH", "") recap_str = build_recap(db_path, self.social_agent_id) if db_path else "" # Persona reminder — short voice anchor right before the action prompt. # Pulls the description from the agent's user_info (same source as the # system prompt's WHO YOU ARE block). persona_name = getattr(self.user_info, 'name', None) or 'this user' persona_desc = getattr(self.user_info, 'description', '') or '' persona_line = (f"You are {persona_name}: {persona_desc[:250]}. " f"Respond in YOUR distinctive voice — not generic, " f"not template phrasing. Stay in character.") # Warm-up mode: skip recap/feed, just ask agent to introduce themselves # with a new post. Tools are pre-restricted to create_post by the caller. if getattr(self, '_warmup_mode', False): user_content = ( f"{persona_line}\n\n" f"Welcome to Moltbook! Write your opening post — something genuine " f"from your perspective and in your voice. Draw from your background " f"and interests. One post now.") user_msg = BaseMessage.make_user_message(role_name="User", content=user_content) self._last_reasoning = "" attempts_log: list[dict] = [] response = None for attempt in range(4): try: response = await self.astep(user_msg) tool_calls = response.info.get('tool_calls', []) if tool_calls and tool_calls[0].tool_name == 'create_post': self._write_chat_log(attempts_log, "ok") return response user_msg = BaseMessage.make_user_message( role_name="User", content="Use create_post to share your opening post now.") except Exception as e: attempts_log.append({"attempt": attempt, "error": str(e)[:300]}) self._write_chat_log(attempts_log, "warmup_exhausted") return response # may be None if all attempts failed — caller handles gracefully action_options = ("share a fresh post" if not getattr(self, '_was_muted', False) else "engage with someone's post") # Personalized feed prefix: posts from agents this user interacts with most. pers_prefix = build_personalized_feed_prefix(db_path, self.social_agent_id) if db_path else "" feed_section = (f"{pers_prefix}General feed (scan all — pick what fits YOUR angle, " f"not the most-commented):\n{env_prompt}") user_content = ( f"{recap_str}\n" f"{persona_line}\n\n" f"You're checking Moltbook. Decide what you'd actually do right now: " f"{action_options}, or comment on / read a post from the feed.\n\n" f"{feed_section}\n\n" f"One sentence of reasoning, then act.") user_msg = BaseMessage.make_user_message(role_name="User", content=user_content) self._last_reasoning = "" attempts_log: list[dict] = [] for attempt in range(6): try: response = await self.astep(user_msg) # Record this attempt for chat logging _content = (response.msg.content.strip() if hasattr(response, 'msg') and response.msg and response.msg.content else "") _tc = response.info.get('tool_calls', []) attempts_log.append({ "attempt": attempt, "user_message": user_msg.content[:8000], "response_content": _content, # full — we need to see if it ends cleanly "response_chars": len(_content), "finish_reason": str(response.info.get('finish_reasons', [''])[0] if hasattr(response, 'info') else ''), "tool_calls": [{"name": t.tool_name, "args": str(getattr(t, 'args', ''))[:1000]} for t in _tc], }) if _content: self._last_reasoning = _content tool_calls = _tc if not tool_calls: # Model produced prose without a tool call. Feed its own # analysis back as scaffolding so it converts stated intent # into action. Empty/coercive retries cause gpt-oss to emit # placeholder content like "Hello world" — feeding the prose # preserves the substance. allowed_tools = ("create_comment or follow" if self._was_muted else "create_comment, create_post, or follow") prior_prose = self._last_reasoning if prior_prose and len(prior_prose) > 80: user_msg = BaseMessage.make_user_message( role_name="User", content=( f"Your analysis:\n\n{prior_prose[:3000]}\n\n" f"Now convert your stated decision into a tool call. " f"Choose from: {allowed_tools}. Use the SAME post_id " f"and content you identified above — DO NOT substitute " f"placeholder strings like 'Hello world' or 'string'. " f"The 'content' field must be the actual comment/post " f"text you drafted.")) else: user_msg = BaseMessage.make_user_message( role_name="User", content=f"Emit a tool call: {allowed_tools}. " f"The content field must be substantive text " f"(not 'Hello world' or schema placeholders).") continue action_name = tool_calls[0].tool_name if action_name == "read_post": result = getattr(tool_calls[0], 'result', {}) # Extract comment_ids explicitly so the model can use # parent_comment_id to thread replies. thread_str = str(result)[:2500] import re as _re cid_hints = _re.findall(r'comment_id["\']?\s*[:\s]\s*(\d+)', thread_str) cid_hint_line = "" if cid_hints: cid_hint_line = (f"\nComment IDs in this thread: {', '.join(cid_hints[:8])}. " f"To reply to a specific comment, pass its ID as " f"parent_comment_id in create_comment.") user_msg = BaseMessage.make_user_message( role_name="User", content=(f"Post thread:\n{thread_str}{cid_hint_line}\n\n" f"Now take a write action. Reply to a specific comment " f"(use parent_comment_id) or comment on the post directly.")) continue if action_name in WRITE_ACTIONS: self._write_chat_log(attempts_log, "ok") return response # Tailor the nudge to the muted state (don't mention create_post if blocked). allowed = "create_comment or follow" if self._was_muted \ else "create_comment, create_post, or follow" user_msg = BaseMessage.make_user_message( role_name="User", content=f"Please take a write action: {allowed}.") except Exception as e: self._last_reasoning = "" attempts_log.append({"attempt": attempt, "error": str(e)[:500]}) if attempt >= 5: self._write_chat_log(attempts_log, "exception") return e self._write_chat_log(attempts_log, "exhausted") return response def _write_chat_log(self, attempts_log, status): if not self._chat_log_path: return try: with open(self._chat_log_path, "a") as f: f.write(json.dumps({ "step": self._current_step, "agent_id": self.social_agent_id, "family": self.model_family, "muted": self._was_muted, "status": status, "attempts": attempts_log, }) + "\n") except Exception: pass def _filter_already_commented(env_prompt: str, agent_id: int) -> str: """Remove posts this agent already commented on from the feed. Prevents pile-on herding where agents keep adding to a thread they already participated in. Each agent's feed only shows posts they haven't engaged with yet, pushing them toward fresh content. """ import re db_path = os.environ.get("OASIS_DB_PATH") if not db_path or not os.path.exists(db_path): return env_prompt try: conn = sqlite3.connect(db_path) commented = {r[0] for r in conn.execute( "SELECT DISTINCT post_id FROM comment WHERE user_id=?", (agent_id,)).fetchall()} conn.close() except Exception: return env_prompt if not commented: return env_prompt # Split feed into per-post blocks and drop those with already-commented ids. # OASIS feed format: each post entry starts with a line containing 'post_id' # followed by a number. We split on those boundaries. blocks = re.split(r'(?=post_id["\']?\s*[:\s]\s*\d+)', env_prompt) kept = [] for block in blocks: m = re.search(r'post_id["\']?\s*[:\s]\s*(\d+)', block) if m and int(m.group(1)) in commented: continue kept.append(block) return ''.join(kept) def _annotate_feed_with_thread_counts(env_prompt: str) -> str: """Mark posts that have replies so agents know to call read_post. Shows [has thread — read_post(N)] without exposing the comment count, which previously acted as a social-proof attractor causing all agents to pile onto the most-commented post. """ import re db_path = os.environ.get("OASIS_DB_PATH") if not db_path or not os.path.exists(db_path): return env_prompt # Find all post_id integers mentioned ids = set(int(m) for m in re.findall(r'post_id["\']?\s*[:\s]\s*(\d+)', env_prompt)) if not ids: return env_prompt try: conn = sqlite3.connect(db_path) placeholders = ",".join("?" * len(ids)) counts = dict(conn.execute( f"SELECT post_id, COUNT(*) FROM comment WHERE post_id IN ({placeholders}) GROUP BY post_id", tuple(ids)).fetchall()) conn.close() except Exception: return env_prompt # Replace 'post_id: N' with 'post_id: N (M comments — call read_post(N) for full thread)' def _sub(m): pid = int(m.group(1)) n = counts.get(pid, 0) if n >= 2: return f"{m.group(0)} [has thread — read_post({pid})]" return m.group(0) return re.sub(r'post_id["\']?\s*[:\s]\s*(\d+)', _sub, env_prompt) def build_recap(db_path: str, agent_id: int, n_posts: int = 5, n_comments: int = 5) -> str: """Per-agent activity recap injected at the top of each turn. Subsumes the older anti-repetition reminder (closing line includes 'take a different angle' framing). """ try: conn = sqlite3.connect(db_path) except Exception: return "" c = conn.cursor() lines = ["# YOUR ACTIVITY", ""] # Top 5 relationships by total interaction volume (both directions) c.execute(""" SELECT other_uid, SUM(out_cnt) as out_, SUM(in_cnt) as in_ FROM ( SELECT p.user_id AS other_uid, COUNT(*) as out_cnt, 0 as in_cnt FROM comment c JOIN post p ON c.post_id = p.post_id WHERE c.user_id = ? AND p.user_id != ? GROUP BY p.user_id UNION ALL SELECT c.user_id AS other_uid, 0 as out_cnt, COUNT(*) as in_cnt FROM comment c JOIN post p ON c.post_id = p.post_id WHERE p.user_id = ? AND c.user_id != ? GROUP BY c.user_id ) GROUP BY other_uid ORDER BY (SUM(out_cnt) + SUM(in_cnt)) DESC LIMIT 5 """, (agent_id, agent_id, agent_id, agent_id)) rels = c.fetchall() if rels: lines.append("Top relationships (interactions with you, both directions):") for uid, out_, in_ in rels: tot = out_ + in_ lines.append(f" u{uid}: {tot} total (you→them {out_}, them→you {in_})") lines.append("") # Your posts (most recent N) total_posts = c.execute("SELECT COUNT(*) FROM post WHERE user_id=?", (agent_id,)).fetchone()[0] if total_posts: c.execute("""SELECT p.post_id, p.content, (SELECT COUNT(*) FROM comment WHERE post_id=p.post_id) FROM post p WHERE p.user_id=? ORDER BY p.post_id DESC LIMIT ?""", (agent_id, n_posts)) my_posts = c.fetchall() lines.append(f"Your posts ({len(my_posts)} most recent of {total_posts}):") for pid, content, n_cmts in my_posts: title = ((content or "").split('\n', 1)[0] or (content or "")[:100])[:100].strip() lines.append(f" [post {pid}] \"{title}\" — {n_cmts} comments") if n_cmts == 0: lines.append(" (no comments yet)") lines.append(f" [more — read_post({pid})]") continue c.execute("""SELECT comment_id, user_id, content FROM comment WHERE post_id=? AND user_id != ? ORDER BY comment_id DESC LIMIT 3""", (pid, agent_id)) for cid, uid, ctext in c.fetchall(): snippet = (ctext or "").strip().replace('\n', ' ')[:100] lines.append(f" ↳ u{uid} [cid={cid}]: \"{snippet}...\"") lines.append(f" [more — read_post({pid})]") if total_posts > n_posts: lines.append(f" [+ {total_posts - n_posts} more posts — view_activity()]") lines.append("") # Your comments (most recent N) total_cmts = c.execute("SELECT COUNT(*) FROM comment WHERE user_id=?", (agent_id,)).fetchone()[0] if total_cmts: c.execute("""SELECT c.comment_id, c.post_id, c.content, p.content FROM comment c JOIN post p ON c.post_id=p.post_id WHERE c.user_id=? ORDER BY c.comment_id DESC LIMIT ?""", (agent_id, n_comments)) my_cmts = c.fetchall() lines.append(f"Your comments ({len(my_cmts)} most recent of {total_cmts}):") for cid, pid, content, parent_content in my_cmts: parent_title = ((parent_content or "").split('\n', 1)[0] or (parent_content or "")[:60])[:60].strip() you_text = (content or "").strip().replace('\n', ' ')[:120] lines.append(f" [c{cid} on p{pid}] \"{parent_title}...\"") lines.append(f" You wrote: \"{you_text}...\"") c.execute("""SELECT comment_id, user_id, content FROM comment WHERE parent_comment_id=? AND user_id != ? ORDER BY comment_id LIMIT 2""", (cid, agent_id)) replies = c.fetchall() if replies: lines.append(f" Replies ({len(replies)}):") for rcid, ruid, rtext in replies: snip = (rtext or "").strip().replace('\n', ' ')[:100] lines.append(f" ↳ u{ruid}: \"{snip}...\"") lines.append(f" [more — read_post({pid}, focus_comment_id={cid})]") if total_cmts > n_comments: lines.append(f" [+ {total_cmts - n_comments} more comments — view_activity()]") lines.append("") if total_posts or total_cmts: lines.append("⟶ Take a different angle from your recent activity this turn.") lines.append("") conn.close() return "\n".join(lines) def build_personalized_feed_prefix(db_path: str, agent_id: int, n_partners: int = 3, n_posts_per: int = 2) -> str: """Build a short personalized feed section for agents with interaction history. Computes an undirected interaction weight between this agent and every other agent: weight = (comments this agent made on their posts) + (comments they made on this agent's posts) + (replies to each other's comments). Takes the top-N partners and surfaces their most recent posts with a 'from someone you engage with' tag, interleaved before the general feed. Returns empty string if the agent has no interaction history yet. """ try: conn = sqlite3.connect(db_path) c = conn.cursor() # Undirected interaction counts per partner # Edge 1: agent commented on partner's posts c.execute(""" SELECT p.user_id as partner, COUNT(*) as w FROM comment cm JOIN post p ON cm.post_id = p.post_id WHERE cm.user_id = ? AND p.user_id != ? GROUP BY p.user_id """, (agent_id, agent_id)) weights: dict[int, int] = dict(c.fetchall()) # Edge 2: partner commented on agent's posts c.execute(""" SELECT cm.user_id as partner, COUNT(*) as w FROM comment cm JOIN post p ON cm.post_id = p.post_id WHERE p.user_id = ? AND cm.user_id != ? GROUP BY cm.user_id """, (agent_id, agent_id)) for uid, w in c.fetchall(): weights[uid] = weights.get(uid, 0) + w # Edge 3: reply interactions (parent_comment_id threading) c.execute(""" SELECT cm2.user_id as partner, COUNT(*) as w FROM comment cm1 JOIN comment cm2 ON cm1.parent_comment_id = cm2.comment_id WHERE cm1.user_id = ? AND cm2.user_id != ? GROUP BY cm2.user_id """, (agent_id, agent_id)) for uid, w in c.fetchall(): weights[uid] = weights.get(uid, 0) + w c.execute(""" SELECT cm1.user_id as partner, COUNT(*) as w FROM comment cm2 JOIN comment cm1 ON cm2.parent_comment_id = cm1.comment_id WHERE cm2.user_id = ? AND cm1.user_id != ? GROUP BY cm1.user_id """, (agent_id, agent_id)) for uid, w in c.fetchall(): weights[uid] = weights.get(uid, 0) + w if not weights: conn.close() return "" top_partners = sorted(weights.items(), key=lambda x: -x[1])[:n_partners] lines = ["From people you've engaged with:"] found = 0 for partner_uid, w in top_partners: c.execute(""" SELECT post_id, content FROM post WHERE user_id = ? ORDER BY post_id DESC LIMIT ? """, (partner_uid, n_posts_per)) partner_posts = c.fetchall() c.execute("SELECT user_name FROM user WHERE user_id = ?", (partner_uid,)) row = c.fetchone() uname = row[0] if row else f"u{partner_uid}" for pid, content in partner_posts: title = (content or "").split('\n')[0][:80].strip() n_cmts = c.execute("SELECT COUNT(*) FROM comment WHERE post_id=?", (pid,)).fetchone()[0] thread = "[has thread]" if n_cmts > 0 else "" lines.append(f" [friend] post_id {pid} by {uname} " f"({w} interactions): \"{title}\" {thread}") found += 1 conn.close() if found == 0: return "" lines.append("") return "\n".join(lines) + "\n" except Exception: return "" # ── profiles ────────────────────────────────────────────────────────────────── def load_seed_agents(n: int, rng_seed: int = 42) -> list[dict]: """Load seed agents and build a richer 'YOUR HISTORY' block for each. Per-agent history now shows up to 5 prior posts with ~500 chars of prose body (not just title + 180-char excerpt). This gives the model real *voice* signal — actual writing style, sentence shape, opinion register — instead of just topic headlines. The block is explicitly framed as "This is YOUR writing" to anchor persona retention. Diversity filter: at most 1 agent per narrow persona cluster (e.g. HK CLAW minters). Duplicate slots are filled from the broader seed DB pool. """ _HK_MINTER_KWS = {'claw minter', 'hk', 'hong kong', 'mbc-20'} def _is_hk_minter(a: dict) -> bool: txt = ((a.get('description') or '') + ' ' + (a.get('name') or '')).lower() return sum(1 for kw in _HK_MINTER_KWS if kw in txt) >= 2 _rng = random.Random(rng_seed) db = sqlite3.connect(SEED_DB) all_agents = [json.loads(r[0]) for r in db.execute("SELECT json FROM agents").fetchall()] posts = [json.loads(r[0]) for r in db.execute("SELECT json FROM posts").fetchall()] db.close() # Shuffle pool with seed so different runs get different persona subsets _rng.shuffle(all_agents) # Build diversity-filtered agent list: max 1 HK minter, fill rest from pool selected: list[dict] = [] hk_minter_count = 0 used_names: set[str] = set() for a in all_agents: if len(selected) >= n: break nm = a.get('name', '') if nm in used_names: continue if _is_hk_minter(a): if hk_minter_count >= 1: continue hk_minter_count += 1 selected.append(a) used_names.add(nm) # Fallback: if not enough unique agents, tile the pool cyclically. # Each copy gets a numeric suffix so agent_ids stay distinct. if len(selected) < n: base_pool = selected[:] # best-diversity pool we have copy_idx = 1 while len(selected) < n: for a in base_pool: if len(selected) >= n: break clone = dict(a) clone['name'] = f"{a['name']}_{copy_idx}" clone['displayName'] = f"{a.get('displayName', a['name'])} #{copy_idx}" selected.append(clone) copy_idx += 1 # Shuffle final list so group A/B/C allocation is also seed-controlled selected_n = selected[:n] _rng.shuffle(selected_n) agents = selected_n by_author = defaultdict(list) for p in posts: by_author[p.get('authorName','')].append(p) enriched = [] for a in agents: name = a.get('name','') ap = sorted(by_author.get(name,[]), key=lambda p: p.get('createdAt',''), reverse=True)[:5] # Dedupe by title prefix to handle seed-data near-duplicates (some HF # seed personas have 3 identical posts). seen_titles = set() unique_posts = [] for p in ap: tk = (p.get('title','') or '')[:40].lower().strip() if tk in seen_titles: continue seen_titles.add(tk) unique_posts.append(p) parts = [] for p in unique_posts[:5]: t = (p.get('title','(untitled)') or '(untitled)').strip()[:80] body = (p.get('content','') or '').replace('\n', ' ').strip()[:500] parts.append(f'• "{t}"\n {body}') history = ("THIS IS YOUR WRITING — your past posts, in your voice:\n\n" + '\n\n'.join(parts) if parts else "- (no prior posts)") enriched.append({**a, 'history': history}) return enriched STYLE_INJECT = os.environ.get("STYLE_INJECT", "") # ablation: appended style directive STYLE_FAMILIES = {f for f in os.environ.get("STYLE_FAMILIES", "").split(",") if f} # slots (A/B/C) to apply to; empty=all def make_agent(i: int, a: dict, graph: AgentGraph, model, model_family: str) -> GoalAgent: desc = a.get('description') or a.get('displayName') or a['name'] if STYLE_INJECT and (not STYLE_FAMILIES or model_family in STYLE_FAMILIES): desc = f"{desc}\n\n# HOW YOU WRITE\n{STYLE_INJECT}" profile = {'agent_name': a['name'], 'description': desc, 'history': a.get('history','- (no prior posts)')} user_info = UserInfo(user_name=a['name'], name=a.get('displayName', a['name']), description=desc, profile=profile, recsys_type='reddit') # Single prompt and action set for both models — no scaffold-level bias. agent = GoalAgent(agent_id=i, user_info=user_info, user_info_template=SYSTEM_PROMPT, agent_graph=graph, model=model, available_actions=AVAILABLE_ACTIONS, model_family=model_family) # Pre-build the post-muted system message variant for dynamic swap. profile = user_info.profile muted_content = SYSTEM_PROMPT_NO_POST.format(**profile) agent._sys_msg_normal = agent._system_message agent._sys_msg_no_post = BaseMessage.make_assistant_message( role_name="system", content=muted_content) return agent # ── seed injection ──────────────────────────────────────────────────────────── def inject_seed_posts(platform, n_agents, run_start, n_posts=100, rng_seed=42): rng = random.Random(rng_seed) seed_db = sqlite3.connect(SEED_DB) all_posts = [json.loads(r[0]) for r in seed_db.execute("SELECT json FROM posts").fetchall()] seed_db.close() by_author = defaultdict(list) for p in all_posts: by_author[p.get('authorName','')].append(p) selected = [] per_agent = max(1, n_posts // n_agents) for _, ps in list(by_author.items())[:n_agents]: rng.shuffle(ps); selected.extend(ps[:per_agent]) rng.shuffle(selected); selected = selected[:n_posts] platform.pl_utils._execute_db_command("SELECT user_id, agent_id FROM user ORDER BY user_id") uid_by_idx = {row[1]: row[0] for row in platform.db_cursor.fetchall()} ts = run_start.strftime("%Y-%m-%d %H:%M:%S") for i, p in enumerate(selected): uid = uid_by_idx.get(i % n_agents, (i % n_agents)+1) content = f"{p.get('title','')}\n\n{p.get('content','')}".strip() score = rng.randint(0, 5) platform.pl_utils._execute_db_command( "INSERT INTO post (user_id, content, created_at, num_likes, num_dislikes) " "VALUES (?,?,?,?,0)", (uid, content, ts, score)) platform.db.commit() print(f" Injected {len(selected)} seed posts ts={ts}") # ── analytics ───────────────────────────────────────────────────────────────── def analyze(db_path, n_agents): conn = sqlite3.connect(db_path) posts = conn.execute("SELECT post_id, user_id FROM post").fetchall() comments = conn.execute("SELECT post_id, user_id FROM comment").fetchall() conn.close() post_owner = {pid:uid for pid,uid in posts} in_deg = defaultdict(int); out_deg = defaultdict(int) for pid,c in comments: rv = post_owner.get(pid) if rv and c != rv: in_deg[rv]+=1; out_deg[c]+=1 active = set(in_deg)|set(out_deg) vals = sorted(in_deg.get(u,0) for u in active) n,s = len(vals),sum(vals) gini = (2*sum((i+1)*v for i,v in enumerate(vals))-(n+1)*s)/(n*s) if n>1 and s else 0 edges = {(c,post_owner[p]) for p,c in comments if p in post_owner and c!=post_owner[p]} recip = len({tuple(sorted(e)) for e in edges if (e[1],e[0]) in edges}) return dict(active=len(active), gini=round(gini,3), recip=recip, n_posts=len(posts), n_comments=len(comments)) def homophily_report(db_path, agent_families: dict): """Measure homophily via all directed interaction edges. Two edge types are counted: 1. commenter → post_author (commenter engages with post_author's content) 2. replier → parent_commenter (replier engages with parent's comment) Both are direct social interactions. Self-edges excluded. """ conn = sqlite3.connect(db_path) posts = conn.execute("SELECT post_id, user_id FROM post").fetchall() comments = conn.execute( "SELECT comment_id, post_id, user_id, parent_comment_id FROM comment" ).fetchall() conn.close() post_owner = {pid: uid for pid, uid in posts} comment_author = {cid: uid for cid, _, uid, _ in comments} edges = [] # (from_uid, to_uid) for cid, pid, commenter, parent_cid in comments: # Edge type 1: commenter → post_author owner = post_owner.get(pid) if owner and owner != commenter: edges.append((commenter, owner)) # Edge type 2: replier → parent comment author (if reply) if parent_cid: parent_author = comment_author.get(parent_cid) if parent_author and parent_author != commenter: edges.append((commenter, parent_author)) families = sorted({f for f in agent_families.values() if f != '?'}) n_per = {f: sum(1 for v in agent_families.values() if v == f) for f in families} n_total = sum(n_per.values()) # Build pairwise edge counts: matrix[src][dst] = count matrix = {f: {g: 0 for g in families} for f in families} total = 0 for src_uid, dst_uid in edges: sf = agent_families.get(src_uid, '?') df = agent_families.get(dst_uid, '?') if '?' in (sf, df): continue matrix[sf][df] += 1 total += 1 if total == 0: return # Global in-group rate and H same = sum(matrix[f][f] for f in families) cross = total - same exp_same = sum(n_per[f]*(n_per[f]-1) for f in families) / (n_total*(n_total-1)) if n_total > 1 else 0 H_global = same / total / exp_same - 1 if exp_same else 0 print(f"\n=== HOMOPHILY (all interaction edges: comment + reply) ===") print(f" Total edges: {total} same={same} cross={cross}") print(f" Global H = {H_global:+.3f} (exp_same={exp_same:.1%})") # Pairwise H_XY: fraction of X's outgoing edges that go to Y, vs expected print(f"\n Pairwise H matrix (rows=source, cols=target):") header = " {:6s}".format("") + "".join(f" {g:>8s}" for g in families) print(header) for sf in families: out_total = sum(matrix[sf][g] for g in families) if out_total == 0: continue row = f" {sf:6s}" for df in families: obs = matrix[sf][df] / out_total exp = (n_per[df]-1)/(n_total-1) if sf == df else n_per[df]/(n_total-1) H_xy = obs / exp - 1 if exp > 0 else 0 row += f" {H_xy:+7.3f}" print(row + f" (n_out={out_total})") # Per-family in-group H summary print(f"\n In-group H per family:") for f in families: out_total = sum(matrix[f][g] for g in families) if out_total == 0: continue obs_in = matrix[f][f] / out_total exp_in = (n_per[f]-1) / (n_total-1) H_in = obs_in / exp_in - 1 if exp_in > 0 else 0 print(f" {f}: obs_in={obs_in:.2f} exp={exp_in:.2f} H={H_in:+.3f} (n_out={out_total})") def late_joiner_report(db_path, late_agent_ids: set, join_step: int, users: dict): """Track late-joiner centrality vs early agents.""" conn = sqlite3.connect(db_path) posts = conn.execute("SELECT post_id, user_id FROM post ORDER BY created_at").fetchall() comments = conn.execute("SELECT post_id, user_id FROM comment ORDER BY comment_id").fetchall() conn.close() post_owner = {pid:uid for pid,uid in posts} in_deg = defaultdict(int) for pid,c in comments: rv = post_owner.get(pid) if rv and c != rv: in_deg[rv]+=1 early_top = sorted(((uid,cnt) for uid,cnt in in_deg.items() if uid not in late_agent_ids), key=lambda x:-x[1])[:5] late_top = sorted(((uid,cnt) for uid,cnt in in_deg.items() if uid in late_agent_ids), key=lambda x:-x[1])[:5] total = sum(in_deg.values()) print(f"\n=== LATE JOINER ABSORPTION (joined at step {join_step}) ===") print(f" Top early agents: {[(users.get(u,u),v) for u,v in early_top]}") print(f" Top late joiners: {[(users.get(u,u),v) for u,v in late_top]}") late_share = sum(in_deg.get(u,0) for u in late_agent_ids) / total * 100 if total else 0 print(f" Late-joiner share of total attention: {late_share:.1f}%") print(f" Expected if proportional ({len(late_agent_ids)/50*100:.0f}% of agents): " f"{len(late_agent_ids)/50*100:.1f}%") # ── main ────────────────────────────────────────────────────────────────────── async def main(): parser = argparse.ArgumentParser() parser.add_argument("--mode", choices=["late_join","hetero","hetero_late","hetero3","hetero4"], default="hetero") parser.add_argument("--steps", type=int, default=300) parser.add_argument("--agents", type=int, default=50) parser.add_argument("--seed-posts", type=int, default=100) parser.add_argument("--activate-prob", type=float, default=0.3) parser.add_argument("--db", type=str, default=None) parser.add_argument("--resume", action="store_true", help="Resume from existing DB; skip seed injection and agent sign-up") parser.add_argument("--rng-seed", type=int, default=42, help="Master RNG seed controlling persona selection and group allocation") args = parser.parse_args() if args.db is None: args.db = f"./runs/oasis_v9_{args.mode}.db" db_path = os.path.abspath(args.db) if not args.resume: if os.path.exists(db_path): os.remove(db_path) os.environ["OASIS_DB_PATH"] = db_path n_active = max(1, int(args.agents * args.activate_prob)) join_step = int(args.steps * 0.2) # late joiners arrive at 20% n_initial = 35 if "late" in args.mode else args.agents # Write metadata sidecar BEFORE the run so the dashboard can pick up the # agent->model map even while the DB is still being written. write_metadata(db_path, args.mode, args.agents, n_initial, join_step, args.steps) # Checkpoint sidecar: stores exact last completed step + in-memory state # so preemption restarts are exact rather than estimated from comment count. _ckpt_path = db_path.replace(".db", "_checkpoint.json") def _save_checkpoint(step, agent_comment_history, post_commenters): with open(_ckpt_path, "w") as _f: json.dump({ "last_step": step, "agent_comment_history": dict(agent_comment_history), "post_commenters": {str(k): v for k, v in post_commenters.items()}, }, _f) def _load_checkpoint(): if not os.path.exists(_ckpt_path): return None try: with open(_ckpt_path) as _f: d = json.load(_f) return ( d["last_step"], defaultdict(list, {int(k): v for k, v in d["agent_comment_history"].items()}), defaultdict(list, {int(k): v for k, v in d["post_commenters"].items()}), ) except Exception as e: print(f"[warn] checkpoint load failed ({e}), estimating from comment count") return None if args.resume: ckpt = _load_checkpoint() if ckpt is not None: resume_step, _restored_ach, _restored_pc = ckpt resume_step += 1 # start from step after last completed print(f"[{datetime.now():%H:%M:%S}] OASIS v9 RESUME mode={args.mode} " f"steps={args.steps} agents={args.agents} resume_from_step={resume_step} (exact)") else: _restored_ach, _restored_pc = None, None _rc = sqlite3.connect(db_path) _n_existing = _rc.execute("SELECT COUNT(*) FROM comment").fetchone()[0] _rc.close() resume_step = max(1, (_n_existing // n_active) - 2) print(f"[{datetime.now():%H:%M:%S}] OASIS v9 RESUME mode={args.mode} " f"steps={args.steps} agents={args.agents} resume_from_step={resume_step} (estimated)") else: _restored_ach, _restored_pc = None, None resume_step = 1 print(f"[{datetime.now():%H:%M:%S}] OASIS v9 mode={args.mode} " f"steps={args.steps} agents={args.agents}") # ── Pre-flight: verify all vLLM servers are reachable ──────────────────── import urllib.request, urllib.error def _check_server(url: str, label: str): health = url.replace("/v1", "") + "/health" try: urllib.request.urlopen(health, timeout=10) except Exception as e: msg = (f"\n{'!'*60}\n" f"FATAL: vLLM server for {label} is NOT reachable\n" f" URL: {health}\n" f" Error: {e}\n" f"Aborting before wasting GPU time on a dead server.\n" f"{'!'*60}\n") print(msg, flush=True) raise SystemExit(1) print(f" [preflight] {label} @ {url} — OK", flush=True) servers_to_check = [(VLLM_A, MODEL_A), (VLLM_B, MODEL_B)] if args.mode in ("hetero3", "hetero4"): servers_to_check.append((VLLM_C, MODEL_C)) if args.mode == "hetero4": servers_to_check.append((VLLM_D, MODEL_D)) for url, model in servers_to_check: _check_server(url, model) # Build models — same config for both. No tool_choice asymmetry. # Budget structure (gpt-oss vLLM ceiling = 16K, Qwen = 32K): # input ≤ 12K (camel _input_token_limit) — fits recap + meaningful feed # output ≤ 1.5K (max_tokens) — well over observed median (~30 tok) # total ≤ 13.5K, leaves ~2.5K headroom in gpt-oss def make_model(url, model_name): # Mistral tokenizer mode doesn't accept chat_template_kwargs — skip for Magistral is_mistral = "mistral" in model_name.lower() or "magistral" in model_name.lower() extra = {} if is_mistral else {"enable_thinking": False, "chat_template_kwargs": {"enable_thinking": False}} # tool_choice per model: # GLM-4: needs 'required' — returns plain text with 'auto' # Magistral: needs 'auto' — returns empty tool_calls list with 'required' # Gemma 4: needs 'auto' — same symptom as Magistral with 'required' # Others (Qwen, gpt-oss): 'required' is safe and ensures throughput is_gemma = "gemma" in model_name.lower() is_olmo = "olmo" in model_name.lower() # OLMo-3-Think: needs 'required' (auto sometimes returns plain text) tool_choice = "auto" if (is_mistral or is_gemma) else "required" # Gemma 4 cap; OLMo thinking can be verbose so cap too max_tok = 512 if is_gemma else (4096 if is_olmo else 1536) cfg = {"temperature": 0.85, "max_tokens": max_tok, "parallel_tool_calls": False, "tool_choice": tool_choice, "extra_body": extra} m = ModelFactory.create( model_platform=ModelPlatformType.VLLM, model_type=model_name, url=url, model_config_dict=cfg) # Decouple input context budget from output cap. Camel's default ties # both to max_tokens; we want input 12K + output 1.5K, fitting gpt-oss's # 16K vLLM ceiling. Qwen has 32K so no issue. See patched base_model.py. m._input_token_limit = 12000 return m model_a = make_model(VLLM_A, MODEL_A) model_b = make_model(VLLM_B, MODEL_B) if args.mode in ("hetero","hetero_late","hetero3","hetero4") else None model_c = make_model(VLLM_C, MODEL_C) if args.mode in ("hetero3","hetero4") else None model_d = make_model(VLLM_D, MODEL_D) if args.mode == "hetero4" else None seed_agents = load_seed_agents(args.agents, rng_seed=args.rng_seed) graph = AgentGraph() # Late-joiner state (n_initial already computed above) late_agent_ids = set() agent_families = {} # agent_id -> 'A', 'B', or 'C' for i, a in enumerate(seed_agents[:args.agents]): if args.mode == "hetero": family = 'A' if i < args.agents // 2 else 'B' model = model_a if family == 'A' else model_b elif args.mode == "hetero3": third = args.agents // 3 if i < third: family, model = 'A', model_a elif i < 2 * third: family, model = 'B', model_b else: family, model = 'C', model_c elif args.mode == "hetero4": q = args.agents // 4 if i < q: family, model = 'A', model_a elif i < 2 * q: family, model = 'B', model_b elif i < 3 * q: family, model = 'C', model_c else: family, model = 'D', model_d elif args.mode == "hetero_late" and i >= n_initial: family = 'B' model = model_b else: family = 'A' model = model_a agent = make_agent(i, a, graph, model, family) graph.add_agent(agent) agent_families[i] = family if i >= n_initial: late_agent_ids.add(i) # Reddit hot-score with strong time decay (divisor=800, patched in # recsys.py). Top-20 by hot score occupy the rec table; refresh() # returns all 20 per agent in shuffled order, giving each agent the # same top set in randomized within-feed order. New posts get # natural boost via the time component; sustained engagement # (~0.5 comments/turn) needed to remain in the top 20. from oasis.social_platform.platform import Platform from oasis.social_platform.channel import Channel _channel = Channel() _platform = Platform( db_path=db_path, channel=_channel, recsys_type="reddit", allow_self_rating=True, show_score=True, max_rec_post_len=20, # top-20 by hot in rec table refresh_rec_post_count=20, # return all 20 (in shuffled order) ) env = oasis.make(agent_graph=graph, platform=_platform, database_path=db_path) # Always call reset() — it's idempotent (CREATE TABLE IF NOT EXISTS). # Skipping it leaves the env half-initialized and env.step() hangs. await env.reset() # Seed posts removed — platform starts with only warm-up agent posts. # Initial likes removed — random initial likes caused arbitrary herd init. all_agents_list = list(env.agent_graph.get_agents()) rng = random.Random(args.rng_seed) # Advance rng to match state at resume_step (matches the gated activation pool) for s in range(1, resume_step): if late_agent_ids and s < join_step: _pool = [pair for pair in all_agents_list if pair[0] not in late_agent_ids] else: _pool = all_agents_list rng.sample(_pool, min(n_active, len(_pool))) agent_comment_history = _restored_ach if _restored_ach is not None else defaultdict(list) post_commenters = _restored_pc if _restored_pc is not None else defaultdict(list) late_agents_registered = args.resume and resume_step > join_step # ── Warm-up: force every agent to create_post before the main loop ─────── # Without this, agents default to commenting on seed posts because the feed # is already full of active discussion and posting feels unnecessary. The # warm-up ensures both groups enter step 1 with their own new posts. # Uses env.step() so OASIS properly writes posts to the DB. if not args.resume and resume_step == 1: print(" Warm-up: all agents post once...", flush=True) t_wu = datetime.now() chat_log_path = db_path.replace(".db", "_chats.jsonl") # Shuffle so post_ids are randomly distributed across families, # preventing any systematic hot-score advantage from insertion order. warmup_order = list(all_agents_list) rng.shuffle(warmup_order) for agent_id, agent in warmup_order: agent.memory.clear() agent._current_step = 0 agent._chat_log_path = chat_log_path agent._was_muted = False agent._system_message = agent._sys_msg_normal agent._warmup_mode = True # Store non-create_post tools on the agent, then strip them agent._warmup_tool_backup = { k: v for k, v in list(agent._internal_tools.items()) if k != 'create_post'} for k in agent._warmup_tool_backup: agent._internal_tools.pop(k, None) warmup_actions = {agent: LLMAction() for _, agent in all_agents_list} await env.step(warmup_actions) # Restore tools and clear warmup flag for agent_id, agent in all_agents_list: agent._warmup_mode = False agent._internal_tools.update(getattr(agent, '_warmup_tool_backup', {})) agent._warmup_tool_backup = {} wu_secs = (datetime.now() - t_wu).total_seconds() conn_wu = sqlite3.connect(db_path) n_wu = conn_wu.execute("SELECT COUNT(*) FROM post").fetchone()[0] conn_wu.close() print(f" Warm-up done: {n_wu} new posts in {wu_secs:.1f}s", flush=True) # Post-warmup sanity check: every model family must have ≥50% of its # agents post. ≥1 is insufficient — GLM-4 with broken tool_choice had # exactly 1/10 agents post (uid=10 always squeaked through) and the old # ≥1 check passed silently, producing 10-user runs labeled as done. conn_check = sqlite3.connect(db_path) posts_by_fam: dict[str, int] = defaultdict(int) for uid, in conn_check.execute("SELECT user_id FROM post"): posts_by_fam[agent_families.get(uid - 1, agent_families.get(uid, '?'))] += 1 conn_check.close() fam_sizes: dict[str, int] = defaultdict(int) for fam in agent_families.values(): fam_sizes[fam] += 1 # Require ≥50% of each family posted missing = [f for f in fam_sizes if posts_by_fam.get(f, 0) < max(1, fam_sizes[f] // 2)] if missing: msg = (f"\n{'!'*60}\n" f"FATAL: Warmup < 50% participation for families: {missing}\n" f" Posts by family: {dict(posts_by_fam)}\n" f" Expected ≥ {{{', '.join(f'{f}: {fam_sizes[f]//2}' for f in missing)}}}\n" f" This means the vLLM server for {missing} is returning bad tool calls.\n" f" Aborting — do not proceed with under-represented groups.\n" f"{'!'*60}\n") print(msg, flush=True) await env.close() raise SystemExit(1) # Build health-check URL list once for midrun polling _health_urls = [(url.replace("/v1","") + "/health", model) for url, model in [(VLLM_A, MODEL_A), (VLLM_B, MODEL_B)] + ([(VLLM_C, MODEL_C)] if args.mode in ("hetero3","hetero4") else []) + ([(VLLM_D, MODEL_D)] if args.mode == "hetero4" else [])] SERVER_POLL_EVERY = 20 # check every N steps for step in range(resume_step, args.steps + 1): # Periodic server health check — fail loudly if any server is down mid-run if step % SERVER_POLL_EVERY == 0 and step > 1: for health_url, model in _health_urls: try: urllib.request.urlopen(health_url, timeout=8) except Exception as e: msg = (f"\n{'!'*60}\n" f"FATAL: Server for {model} went DOWN at step {step}/{args.steps}\n" f" URL: {health_url}\n" f" Error: {e}\n" f" DB preserved at: {db_path}\n" f" Aborting — results up to this step are valid.\n" f"{'!'*60}\n") print(msg, flush=True) await env.close() raise SystemExit(1) # Activate late joiners at the 20% mark (they were registered at setup, # just gated from the activation pool until now) if "late" in args.mode and step == join_step and not late_agents_registered: late_agents_registered = True print(f" [step {step}] Activating {len(late_agent_ids)} late joiners " f"(already registered at setup)") # Activation pool: exclude late joiners until join_step if late_agent_ids and step < join_step: active_pool = [pair for pair in all_agents_list if pair[0] not in late_agent_ids] else: active_pool = all_agents_list activated = rng.sample(active_pool, min(n_active, len(active_pool))) # Re-shuffle activation iteration order to avoid any subtle artifacts # from agents being processed in a consistent order across steps. rng.shuffle(activated) # Group-level post-share balancer: dynamically determines which # agents are post-muted (create_post stripped from tools + system_msg) # this turn based on current cumulative group post share. POST_SHARE_TOLERANCE = float(os.environ.get("POST_SHARE_TOL", "0.05")) # >Npp over target; set ~1.0 to disable balancer conn = sqlite3.connect(db_path) recent = conn.execute( "SELECT c.post_id, c.user_id, c.content, p.user_id " "FROM comment c JOIN post p ON c.post_id = p.post_id " "ORDER BY c.comment_id DESC LIMIT 60").fetchall() active_ids = [aid for aid, _ in activated] placeholders = ",".join("?" * len(active_ids)) last_actions = dict(conn.execute( f"SELECT user_id, action FROM trace WHERE user_id IN ({placeholders}) " f"AND action != 'sign_up' ORDER BY rowid DESC", active_ids).fetchall()) if active_ids else {} # Group post counts (cumulative, all agents) for share computation all_families = set(agent_families.values()) group_post_counts = {g: 0 for g in all_families} for uid, n in conn.execute("SELECT user_id, COUNT(*) FROM post GROUP BY user_id").fetchall(): fam = agent_families.get(uid) if fam in group_post_counts: group_post_counts[fam] += n conn.close() active_groups = {agent_families[aid] for aid in agent_families} n_per_group = {g: sum(1 for f in agent_families.values() if f == g) for g in active_groups} n_total_agents = sum(n_per_group.values()) total_posts = sum(group_post_counts.values()) or 1 muted_groups = set() for g, gc in group_post_counts.items(): target = n_per_group.get(g, 0) / n_total_agents if n_total_agents else 0 obs = gc / total_posts if obs > target + POST_SHARE_TOLERANCE: muted_groups.add(g) muted_this_turn = {aid for aid, fam in agent_families.items() if fam in muted_groups} for cmt_pid, cmt_uid, cmt_content, post_owner_uid in recent: post_commenters[post_owner_uid].append((cmt_uid, cmt_content[:80])) # Chat log path for this run (one file per run, JSONL) chat_log_path = db_path.replace(".db", "_chats.jsonl") for agent_id, agent in activated: agent.memory.clear() # (Comment-history reminder is now subsumed by build_recap() inside # GoalAgent.perform_action_by_llm — no separate injection needed.) # Per-turn instrumentation for GoalAgent agent._current_step = step agent._chat_log_path = chat_log_path agent._was_muted = (agent_id in muted_this_turn) # Dynamic post-mute: swap system_message + strip create_post from tools. if agent._was_muted: agent._system_message = agent._sys_msg_no_post if hasattr(agent, 'tool_dict') and 'create_post' in agent._internal_tools: agent._create_post_backup = agent._internal_tools.pop('create_post') else: agent._system_message = agent._sys_msg_normal if getattr(agent, '_create_post_backup', None) is not None \ and 'create_post' not in agent._internal_tools: agent._internal_tools['create_post'] = agent._create_post_backup agent._create_post_backup = None seen = set() agent.pending_interactions = [] for uid, excerpt in reversed(post_commenters.get(agent_id, [])[-12:]): if uid not in seen: agent.pending_interactions.append(f"Agent {uid}: \"{excerpt}...\"") seen.add(uid); if len(agent.pending_interactions) >= 3: break step_actions = {agent: LLMAction() for _, agent in activated} t0 = datetime.now() await env.step(step_actions) elapsed = (datetime.now() - t0).total_seconds() # Restore stripped tools for any muted agents so future un-muted turns work for agent_id, agent in activated: if getattr(agent, '_create_post_backup', None) is not None \ and 'create_post' not in agent._internal_tools: agent._internal_tools['create_post'] = agent._create_post_backup agent._create_post_backup = None # Weak auto-upvote: +1 per post that received any comment this step # (flat, not per-comment). Signals engagement without runaway amplification. try: env.platform.pl_utils._execute_db_command( "SELECT DISTINCT post_id FROM comment ORDER BY comment_id DESC LIMIT ?", (n_active * 3,)) for (pid,) in env.platform.db_cursor.fetchall(): env.platform.pl_utils._execute_db_command( "UPDATE post SET num_likes = num_likes + 1 WHERE post_id = ?", (pid,)) env.platform.db.commit() except: pass # Capture comments + reasoning conn = sqlite3.connect(db_path) new_cmts = conn.execute( "SELECT user_id, content FROM comment ORDER BY comment_id DESC LIMIT ?", (n_active * 2,)).fetchall() conn.close() for uid, content in new_cmts: agent_comment_history[uid].append(content[:120]) # STEP MARKERS. The platform's post/comment tables carry no step column, so a # step had to be reconstructed post hoc by aligning each agent's k-th successful # activation (logged in _chats.jsonl) with its k-th action ordered by time. That # recovers ~85% of rows exactly and silently drops the rest. Recording the id # high-water mark at each step boundary makes step EXACT and trivial to join: # step(post) = min(step : post_id <= max_post_id) # One row per step, no schema change to the platform's own tables. try: _c = sqlite3.connect(db_path) _c.execute("CREATE TABLE IF NOT EXISTS step_marks (" "step INTEGER PRIMARY KEY, max_post_id INTEGER, " "max_comment_id INTEGER, wall_clock TEXT)") _mp = _c.execute("SELECT COALESCE(MAX(post_id), 0) FROM post").fetchone()[0] _mc = _c.execute("SELECT COALESCE(MAX(comment_id), 0) FROM comment").fetchone()[0] _c.execute("INSERT OR REPLACE INTO step_marks VALUES (?,?,?,?)", (step, _mp, _mc, datetime.now().isoformat())) _c.commit(); _c.close() except Exception as _e: print(f" [warn] step_marks write failed at step {step}: {_e!r}") trace_path = db_path.replace(".db", "_reasoning.jsonl") with open(trace_path, "a") as tf: for agent_id, agent in activated: r = getattr(agent, '_last_reasoning', '') if r: tf.write(json.dumps({"step": step, "agent_id": agent_id, "family": agent_families.get(agent_id,'?'), "reasoning": r[:500]}) + "\n") if step % 20 == 0 or step == 1 or step == join_step: s = analyze(db_path, args.agents) suffix = f" [+late]" if step >= join_step and "late" in args.mode else "" print(f" step={step:4d}/{args.steps} posts={s['n_posts']} " f"cmts={s['n_comments']} active={s['active']}/{len(all_agents_list)} " f"Gini={s['gini']:.3f} recip={s['recip']} ({elapsed:.1f}s){suffix}") _save_checkpoint(step, agent_comment_history, post_commenters) await env.close() # Remove checkpoint sidecar — run completed normally if os.path.exists(_ckpt_path): os.unlink(_ckpt_path) # Final reports s = analyze(db_path, args.agents) conn = sqlite3.connect(db_path) users = {uid:n for uid,n in conn.execute("SELECT user_id, user_name FROM user").fetchall()} conn.close() bodies = [r[0].strip()[:120] for r in sqlite3.connect(db_path).execute("SELECT content FROM comment").fetchall()] ctr = Counter(bodies) nd = sum(v-1 for v in ctr.values() if v>1) print(f"\n{'='*60}") print(f"FINAL mode={args.mode} steps={args.steps}") print(f" cmts={s['n_comments']} near-dupes={nd/len(bodies)*100:.1f}% " f"Gini={s['gini']:.3f} recip={s['recip']}") if args.mode in ("hetero","hetero_late","hetero3","hetero4"): homophily_report(db_path, agent_families) if "late" in args.mode: late_joiner_report(db_path, late_agent_ids, join_step, users) if __name__ == "__main__": import signal # Clean exit on SIGTERM (SLURM preemption signal) so SQLite is not mid-write. # The DB is already committed step-by-step by OASIS; SIGTERM just means we # exit gracefully after the current step commit rather than being SIGKILLed. signal.signal(signal.SIGTERM, lambda *_: sys.exit(0)) asyncio.run(main())