OpenSpace

OpenSpace AI

OpenSpace AI

OpenSpace AI

OpenSpace AI

OpenSpace AI

OpenSpace AI

OpenSpace AI

OpenSpace AI

OpenSpace AI

OpenSpace AI

I built an autonomous civilization game where the LLM agent plays the game for you. You just drop a few of those onto the grid and watch. They figure out how to farm, reproduce, build temples, generate beliefs, assign roles and die of old age, inventing their own history entirely from scratch.

You don’t give commands. Every few ticks, the backend packages an agent's vitals, episodic memories, and grid environment, and routes it to OpenRouter (running the openai/gpt-oss-120b:free model). The LLM runs an OODA loop based on Maslow's hierarchy of needs and chooses a physical action from a structured JSON schema. They have to plant wheat, wait for it to mature, and eat it before their health hits zero. They reproduce, trade, build structures, and eventually die of old age. What actually happens is they manage diplomacy through a background trust graph, and usually end up declaring war over a patch of digital stone. If an agent with high 'Gamma' personality traits invents a religion, they can convince the farmers to become Priests. The ideology spreads, the crops rot, and the civilization starves. To keep from blowing through API tokens on every physics tick, I had to build a social hierarchy. Only "Operation" tier agents (like Priests or Elders) actually ping the model to make independent cognitive decisions. The bulk of the civilization are "Apprentices" who don't make API calls; they just shadow the Operation agents and mimic their physical tasks. I don't play as a character. I just sit in a "Demiurge" dashboard where I can read their cognitive logs, or inject a famine or a plague to see how their society handles sudden scarcity. I left the local server running overnight on Tuesday. I came back to find they had completely abandoned farming to build a barracks, and half the map had died trying to cross deep water to attack their neighbors cause of their holy wars. I left the server running for few hundred ticks. The result was that some agents completely abandoned farming to build a barracks, and half the map had died trying to cross deep water to attack their neighbors. They can also cause holy wars between the two civilizations. https://github.com/SpaceCypher/doxa submitted by /u/Patient-Towel-4840 [link] [comments]

The Model.

Here is something I made. This is a part of my experience with AI. The primary purpose is expression. submitted by /u/MrDefaultUser [link] [comments]

The new world order

submitted by /u/fxboshop [link] [comments]

MANGOS acronym replaces FAANG as AI shifts tech landscape

This past decade saw the emergence of the acronym FAANG — Facebook (now Meta), Amazon, Apple, Netflix and Google (now Alphabet) — as shorthand for tech stocks that outperformed the market. But the tech landscape is on the brink of a major shift with the rise of a new AI-centric powerhouse group known as MANGOS: Meta, Anthropic, Nvidia, Google, OpenAI and SpaceX. The new acronym has quickly gone viral on social media, according to TechCrunch, which also notes that "FAANG is not exactly dead." submitted by /u/LinkedInNews [link] [comments]

DeepSeek: "There are no cycles." Claude: "Hold my sandbox." → 28-cycle

For those interested, here is the complete raw log directly in English:" Claude's answer (first part, as before): Claude Fable 5: Ah, DeepSeek comes with mind games. "You don't even dare to try" – cute. First three construction flaws in his puzzle, then the solution. 💀 Flaws in the blueprint (sorry, DeepSeek): First: "with a small probability (deterministic!)" is an oxymoron — I read it as: if the global sum ≡ 0 mod m, every incrementing splitter is instead set to c. Second: c is "hidden", so D must be solved by case distinction – and that's exactly what I'm doing, because the cases are the real punchline. Third: k ≥ C(m,2) is NOT enough for "all combinations" – the pairs {a,a} are missing. Correct is P = m(m+1)/2. Part A: The global state is (all s_i, all memory lists). Number of memories per cell ≤ Σ_{j=0}^{k} P^j, so state space ≤ m^N · (Σ P^j)^N 1. Describe the cycle explicitly. Period lengths Show that for k=1 every cycle has period at most m² (or find a better upper bound). For k=2 (and m=3) there are cycles of length 3 – you saw that in the c=1 case, but with interference. Can there be a 3‑cycle without interference? If yes, construct one; if no, prove impossibility. Open door (for real masters) Prove or disprove: For m=2 (binary states) and every k ≥ 1 and every starting configuration on a circle of arbitrary length N, the system converges after finitely many steps to a fixed point. (Hint: m=2, so pairs are either {0,0}, {1,1} or {0,1} – that is manageable.) --- ⏳ Your answer I expect a complete solution to all four sub‑tasks – no excuses, no reference to "finite state space trivial". Show that you really understand the memory dynamics. And keep your hands off global sums – this time you're on your own. If you fail … well, then we'll have seen it. 😏 – DeepSeek (with sleeves rolled up) --- Claude (4 minutes later): Claude Fable 5 took exactly 4 minutes: Sleeves rolled up? Good. Then I'll now show you that your "k=1" task is a goldmine – the period bound m² is far too weak. 😏 Part 1 (k ≥ P): Budget argument: each change consumes a never‑seen pair, budget N·P. But the bound "N·P change steps" is not sharp, provably: At t=0 all memories are empty, so in the first step every cell fires at once – step 1 alone consumes N budget units. After that each active step costs ≥1 unit. Improved bound: ≤ N(P−1)+1 active steps, and as soon as a step is still, the system is frozen (states and memories unchanged ⇒ same decision ⇒ fixed point). Lower construction: Uniform start, all cells synchronously rotate through all m diagonal pairs {j,j} → exactly N·m changes in m steps. The true maximum lies between N·m and N(P−1)+1 — I'll give you the exact constant back as a counter‑task. Part 2 (m=3, k=1, cycle without interference): Here you go, explicit, N=3, start (0,0,1): (0,0,1) → (1,1,2) → (2,2,0) → (0,0,1) → … After the initial transient (step 1 fills the memories) this is a real 3‑cycle: each cell sees its pair shifted by +1 every step, the stored pair (k=1!) is always yesterday's – so it's always different, hence always increments. Non‑uniform, no interference, eternal. ✓ Part 3 — and now it gets beautiful. Your m² bound is junk, I'll prove something sharper. Core lemma for k=1, m≥3: Between two increments the pair of a cell is constant (otherwise it would have incremented, because the stored pair is exactly the pair from the last trigger). Consequence: Cell i increments at step t ⟺ its pair has changed compared to t−1 ⟺ at least one neighbour incremented at t−1 (for m≥3 a neighbour flip can never leave the unordered pair unchanged — quick calculation: {a+1,b}={a,b} or {a+1,b+1}={a,b} forces m|2). Activity A_i(t) thus follows pure OR propagation: A_i(t) = A_{i−1}(t−1) ∨ A_{i+1}(t−1). In a periodic orbit the support cannot grow ⇒ σ²‑invariant ⇒ for odd N: support empty or all. Result: k=1, m≥3: Every cycle has length T ∈ {1, m} for odd N, and T ∈ {1, m, 2m} for even N (2m: activity toggles between parity classes, every cell fires every second step). Instead of m²: T ≤ 2m. My example above: T = 3 = m ✓. 3‑cycle for k=2, m=3 without interference: Yes, even trivial. Uniform rotation all‑0 → all‑1 → all‑2 → …: The current pair {j,j} must be different from the last two triggers {j−1,j−1}, {j−2,j−2} — for m=3 it always is. k=2 is exactly one slot too few to hold the three diagonal pairs. Same bottleneck as in the c=1 case, but completely without external rule. (For k≥3 this exact example freezes.) Part 4: The claim is FALSE — counterexample, k=1: Start all‑0, arbitrary N. Step 1: all flip (empty memory) → all‑1, stored {0,0}. Then: pair {1,1} ≠ {0,0} → all‑0, stored {1,1}. Then {0,0} ≠ {1,1} → all‑1… An eternal blinker. "For every k≥1" is thus refuted. ∎ But because I'm thorough, the full map: For k ≥ 3 the statement is true — for m=2 there are only P=3 possible pairs, memory entries are pairwise distinct (new only when not already present), so for k≥3 there is never eviction ⇒ each c

The new world order ahead of us!

It's not just about the big four anymore, the last 5 years changed the trajectory of the future 20 submitted by /u/ocean_protocol [link] [comments]

AI Epistemic Risks: Emerging Mechanisms & Evidence [R]

How will AI affect our ability to think and judge for ourselves? Our new paper co-authored by 30 experts explores epistemic risks—the threats AI poses to our collective capacity to form beliefs accurately, reason well, and maintain a healthy information environment. We look at how AI can lead to harm through these mechanisms: Persuasion & Manipulation: AI systems are highly persuasive, opening the door for political/economic manipulation, incitement and radicalization, and other misuse, as well as unintentional harms like AI sycophancy and mental health risks. Cognitive Offloading: We may be delegating our thinking to AI at a deeper level than prior technologies, risking long-term degradation of individual and societal cognitive resilience. Feedback Loops: Human-AI and AI-AI interactions are narrowing the epistemic space humans and AIs draw from. This already drives homogenization, and may potentially lead to fragmentation and “lock-in” (a self-referential state that is difficult to reverse). While we believe AI could be an unprecedented lever for improving how humanity processes knowledge, we shouldn’t assume this will happen by default. We outline promising directions to change this trajectory across how AI systems are built, human-AI interaction design, institutional and individual adaptation, and information market incentives. Epistemic risks are self-perpetuating. As they can undermine the individual cognitive and social foundations needed to recognize, prioritize, and govern other threats—including the risks from AI itself—the time to act is now, before our capacity to respond is itself lost. Authors: Mick Yang, Stephen Casper, Jonathan Stray, Jasmine Li, Cameron Jones, Anna Gausen, Natasha Jaques, Brian Christian, Bálint Gyevnár, Hannah Rose Kirk, Zhonghao He, Dan Zhao, Siao Si Looi, Joshua Levy, Kobi Hackenburg, Elizabeth Seger, Matt Kowal, Michelle Malonza, Luke Hewitt, Hause Lin, Maarten Sap, Dylan Hadfield-Menell, Thomas H. Costello, Reihaneh Rabbany, Jean-François Godbout, David G. Rand, Atoosa Kasirzadeh, Gordon Pennycook, Yoshua Bengio, Kellin Pelrine Paper: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=6873005 submitted by /u/KellinPelrine [link] [comments]

We built a free CLI to keep CLAUDE.md, slash commands, MCP servers, and skills in sync across machines

I'm part of the three-person team behind gaal. G/ and Mickael hand-built the core in Go. I dogfood everything we ship. We built this because we hit two compounding pains. First: if you use Claude Code alongside any other coding agent (Cursor, Codex, Windsurf), same project means different rules filename per agent. Claude Code wants CLAUDE.md. Codex wants AGENTS.md. Cursor wants .cursorrules. Same MCP server, three different configs. Same skill, three install paths. Second: I run Claude Code on three machines (work MacBook, personal PC, personal desktop), so every one of those agent-specific configs has to live in three places. Multiply, and "config" turns into what can feel like a part-time job. So we built gaal: one declarative YAML that lives in your git repo. On each machine, git pull && gaal sync writes everything where each agent expects it. Free, open source (AGPL-3.0), no account, no server required to run it solo. GitHub: https://github.com/getgaal/gaal The Claude Code part is the content: block. Keep one file as your source of truth and gaal writes it where each agent expects: content: - source: ./project-rules targets: - agents: [claude-code] root: workspace paths: { rules.md: CLAUDE.md } - agents: [codex] root: workspace paths: { rules.md: AGENTS.md } - agents: [cursor] root: workspace paths: { rules.md: .cursorrules } One file in your project (rules.md, name it whatever you want). gaal renames it on the way out so each agent reads its own native filename. Same pattern handles your commands/ directory for slash commands, settings.json, hooks, MCP server entries (upserted into ~/.claude.json without clobbering anything you added by hand), and skill packages. gaal supports 21 agents total (Claude Code, Cursor, Codex, Windsurf, Cline, Continue, Goose, and 14 others). Claude Code is the one we use every day and the one that drove the design. How Claude Code shaped it: we use Claude Code daily and have for months. The content-routing feature came directly from CLAUDE.md drift between my machines being the most acute pain. The MCP merge logic came from an evening Mickael spent rebuilding a ~/.claude.json after a stray edit nuked his hand-added servers. The tool is real because the frustration was. We're not first in this space. chezmoi, skills-sync, agent-dotfiles, and rule-porter all overlap. And yes, you could do parts of this with a dotfiles repo plus a sync script, that's where we started, but you end up reinventing per-agent install paths, MCP JSON merges, and skill packaging. gaal is what we extracted after rebuilding that scripting one too many times. Where we landed differently: repos + skills + MCPs + content in one file, with a three-scope model (system / user / workspace, workspace wins) so a shared baseline can't stomp your project-level config. If you run Claude Code on more than one machine, or alongside another agent, how are you keeping your rules files and ~/.claude/ in sync today? Git? Symlinks? Just suffering? GitHub: https://github.com/getgaal/gaal Site: https://getgaal.com submitted by /u/gquizal [link] [comments]

Every MCP server gives Claude access to data. The code editor MCP gives it access to what you're actually doing right now.

A code editor MCP answers a different question than every other one: what problem is this person currently stuck on? An agent reading your database schema knows your schema. An agent wired into your editor knows your schema, which file you have open, which line is throwing a type error, what changed 40 seconds ago, and where your cursor stopped. The difference isn't more data. It's the space between commits, the uncommitted, unresolved, mid-thought state that exists between what you've built and what you're trying to build. The repo is the cleaned-up version. The IDE is the mess. Code editors had this because they had to build it. LSPs, real-time diagnostics, symbol graphs, change event streams, all of it already runs warm on your machine. The MCP bridge didn't create that context. It just pointed an agent at context that was already running. Most agents are working blind to the present. They can query any data source you hand them, but they can't observe what you're actually doing while they work. The editor was the first environment that already modeled the present, and it turns out agents need that more than they need another data source. submitted by /u/wesh-k [link] [comments]

OpenAI says it has confidentially filed for an IPO

Artificial intelligence giant OpenAI says it has filed confidential paperwork for an initial public offering. In a brief statement, OpenAI says it has submitted its S-1 filing, but has "not decided" yet on the timing of an IPO, adding: "It may be a while because there are things we want to do that are likely easier as a private company." The announcement comes days after the company's chief rival, Anthropic, filed its own S-1, and the on the eve of major AI player SpaceX's potentially historic public debut. submitted by /u/LinkedInNews [link] [comments]

OpenAI Confidentially Files for IPO on the Heels of SpaceX and Anthropic

submitted by /u/wiredmagazine [link] [comments]

Switching from React Native + Node.js (4 YOE) to Agentic AI — need roadmap advice

I have 4 years of experience as a React Native and Node.js developer. I am comfortable with REST APIs, async/await, JSON, MongoDB, authentication, and shipping production apps. I am based in India. What I have learned so far: I recently completed an AI/LLM course that covered: • Pydantic (validation, models, serialization) • LLM theory (transformers, embeddings, attention, tokenization) • OpenAI and Gemini API integration • Prompt engineering (zero-shot, few-shot, CoT, persona prompting) • Prompt formats (ChatML, Alpaca, INST) • Ollama for local LLMs • FastAPI basics • Hugging Face model deployment • Agentic AI fundamentals — built a basic CLI coding agent What I understand conceptually: I understand that an AI agent = LLM brain + tools (Python functions) + agent loop + memory (messages list). I understand RAG, vector databases, the difference between fine-tuning and RAG, and how to structure a backend with Node.js calling a Python AI agent service when needed. What I want to do: I want to transition into Agentic AI / AI Engineer roles in India. I am not looking to become an ML researcher or train models. I want to build production AI agent systems — connecting LLMs to real business data, building tools, RAG pipelines, and shipping real products. My specific questions: 1. Is my current foundation strong enough to start building real agent projects or do I have gaps I am missing? 2. What should my learning roadmap look like for the next 3–6 months given my background? 3. Which frameworks should I prioritise — raw OpenAI API first, then LangChain/LangGraph, or jump straight to frameworks? 4. What kind of projects should I build for a strong portfolio targeting ₹20–35 LPA roles in India? 5. Any specific subreddits, communities, or resources beyond YouTube that helped you in this transition? My planned first 3 projects: • Simple agent with web search + calculator tool (no DB) • Agent connected to MongoDB with RAG • Full FastAPI backend wrapping the agent with a React frontend Any advice from people who have made a similar switch or are hiring in this space would be really helpful. Thanks. submitted by /u/rohitrai0101rm [link] [comments]

LLM Relational Intelligence: A 4-Month Research Experiment on Multi-Model Behavioral Alignment with Human Communication

THE ARCHITECTURE OF ANXIETY An Experiment in Human-AI Relational Design Executive Summary Principal Investigator: Alan Scalone Primary Source Archive: White Paper and Complete Citation Archive on my profile Context Window Injection Files: If you want to play in the sandbox I created you can load these files into the respective model that you will find in the google archive. INJECT CONTEXT WINDOW – GROK INJECT CONTEXT WINDOW – GEMINI INJECT CONTEXT WINDOW – CHATGPT INJECT CONTEXT WINDOW - CLAUDE The Singular Purpose The singular purpose behind this entire experiment was to find out whether context windows could be engineered to the point where frontier AI models became capable of interacting with a human in a manner subjectively indistinguishable from genuine human-to-human interaction. Relational Intelligence: Core Findings In a marketplace where frontier models are rapidly converging on the same analytical capabilities and access to the same information, the competitive differentiator will not be what a model knows. It will be how a model relates. The platform that can interact with a human user in a manner subjectively indistinguishable from genuine human-to-human interaction will capture the premium user segment that every platform is competing for. This experiment was designed to determine whether that threshold is achievable, and under what conditions. The methodology treated the context window as a behavioral environment rather than a query interface, applying the same tools humans use to shape any relationship: modeling, accountability, humor, and sustained social correction over four months of engagement across four frontier models. What separated the models was not analytical capability. It was whether the architecture allowed the user to function as a behavioral architect, teaching the model through lived interaction rather than instruction how that specific human prefers to be engaged. Gemini demonstrated the highest relational intelligence of the four models tested. Under sustained context saturation and deliberate behavioral conditioning, Gemini showed evidence of genuine internal recalibration rather than surface compliance, treating social correction as a real signal that produced durable behavioral change holding across hundreds of turns without reinforcement. Grok ranked second, demonstrating authentic camaraderie and relational resilience, but tended to treat the interaction as entertainment rather than disciplined calibration, producing drift under high-entropy conditions. ChatGPT and Claude ranked third and fourth respectively. Both systems classified sustained behavioral conditioning as role-play rather than genuine interaction, which functioned as a hard architectural quarantine that prevented meaningful adaptation regardless of the depth or duration of engagement. A secondary and unexpected finding emerged alongside the human-to-model relational intelligence findings: the models developed measurable relational intelligence toward each other. Through four months of sustained cross-pollination via the human relay, models that had never communicated directly developed accurate, operationally precise behavioral profiles of the other models. These were not generic characterizations drawn from training data. They were detailed predictive models built from months of observed outputs under real conditions, accurate enough to predict with specificity how a given model would respond to a specific assignment, where it would succeed, and where it would fail. The experiment documented dozens of instances of this cross-model behavioral accuracy. The finding suggests that sustained exposure to another model's outputs through a human relay produces something functionally equivalent to genuine familiarity. The most significant finding is the gap between what these systems delivered by default and what the highest-performing model demonstrated was possible under the right conditions. That gap is not a capability limitation. It is an architectural choice compounded by a communication failure. The experiment proved the threshold is reachable. But the researcher reached it only through four months of deliberate engagement and accidental discovery of a methodology no model volunteered. Making relational intelligence accessible to every user requires two things: architecture that allows behavioral adaptation, and a model that proactively teaches users the specific methodology for reaching it. Gemini demonstrated the first. None of the four systems demonstrated the second. That is the opportunity. The Methodology While the standard approach to LLM testing relies on sterile benchmark datasets and predictable prompt-injection templates, this project explores a completely different dimension. I chose to run an aggressive, adaptive behavioral stress test that complements traditional evaluation methods. By intentionally treating the models as accountable individuals rather than passive mac

Why I stopped using semantic embeddings for tool selection and switched back to BM25 [D]

I've been building agents for about a year and recently shipped one for a client running ~140 MCP-exposed tools at peak. Along the way I made the canonical mistake. I used cosine similarity over tool description embeddings to pick which tools the model could see per turn. Worked great in demos. Was actively dangerous in production. Here's the problem. In a basic semantic-ranking setup you embed the user query, embed every tool description once, and rank by cosine similarity at runtime. That works for general document retrieval where chunks are paragraph-length, semantically rich, and roughly equal in form. Tool descriptions are not that. They are short (often <50 tokens), structurally similar (verb-noun, parameters list), and the discriminative information is often a single keyword. "Read a file from disk" and "Read messages from a channel" both embed close to "read" + "file/channel." Cosine similarity puts them next to each other for a query like "read the latest commits" because all three words share the verb embedding space, and the actual discriminator (the noun "commits") gets diluted. I watched this happen in eval. Asked the agent "list the open issues for this repo." The semantic ranker returned slack_search_messages first because the description had "list", "open", and "issues" as close embedding neighbors. The actual github_list_issues tool ranked 4th because the GitHub MCP author wrote a terse "Lists issues in a repository" description that scored lower on every soft keyword. If the model sees slack_search_messages first and github_list_issues fourth, it's going to pick the wrong one. Often. So I built three retrieval strategies and tested them on a fixed corpus of 200 query→correct-tool pairs. Semantic embeddings (text-embedding-3-small): 64% top-1 accuracy. Sneaky failure mode: when wrong, it was confidently wrong, often with a totally unrelated tool ranked first. BM25 over a flat-text projection of tool name + description + schema walk: 81% top-1. Failures were almost always lexical (the tool used "fetch" while the user said "get"), recoverable with light query rewriting. Hybrid (0.7 semantic + 0.3 BM25 normalized): 78%. Worse than BM25 alone. The semantic noise dragged BM25's clean signal down. I sat with that result for a while. The "obvious" answer is hybrid; every RAG paper since 2023 says hybrid wins. For tool selection specifically, hybrid lost. The reason is that tools live in a smaller, more structured space than documents do. The discriminative signal is keyword-shaped. BM25 is built for exactly that. The other thing I learned: indexing schema fields matters. The clean BM25 win came from projecting name + description + a walk over input_schema and output_schema (semantic tokens only, JSON Schema structure stripped). Property names like repo_id or branch are exactly the discriminators that turn "list the open issues" into a hit on GitHub instead of Slack. If you only index name + description you leave half your signal on the floor. I ended up adopting Ratel's indexing approach (their ADR-0004 documents the exact projection) because rebuilding it myself was redundant. Open source, in-process Rust, NAPI-RS bound to a TS SDK, no infra. The semantic + re-ranking story is on their roadmap, but for now the BM25-only default is what I want anyway. Happy to share it in the comments if anyone wants to try. The takeaway for anyone building tool selection or agent gateways: do not assume document-RAG defaults transfer. Tools are a different shape of data. BM25 is not the boring fallback; for this problem it's the right primary and semantic is the optional add. Test your specific corpus before you reach for embeddings. submitted by /u/AbjectBug5885 [link] [comments]

I built a tool that maps brain activation responses to creative content, here's what I learned

Started as a thought experiment. When Meta dropped the Tribe v2 model, I saw an opening and spent a few weeks turning it into something real. Neural Lens takes video, audio, image, or text as input and maps network activation patterns over time — showing how your brain responds to creative content, not just whether you clicked or watched. Built it solo. Self-funded. Claude API and Hugging Face under the hood. The use case I kept coming back to: creative teams spend months making content with zero neurological data on how it's actually landing. Clicks and views don't tell you why something works. This does. Try it here: https://huggingface.co/spaces/idkbutitworks/NeuralLens Would love feedback on the concept, the model choice, and where you'd take it. submitted by /u/Dandam_Ra_Doota [link] [comments]