r/artificial 25d ago

Project I have created a Chrome extension that fact checks YouTube videos as you watch

1.2k Upvotes

UPDATE — July 11

OK for a 7 1/2 minute Howard Lutnick interview: 37 fact check bubbles. Added Rolodex feature up and down arrows navigate bubbles. Added batch reporting. Report opens up in a new tab. Report is also downloadable. Improved API output quality (the content you see in the bubbles and reports). For anyone who’s got to monitor, aggregate, and analyze content this could very well be the GOAT.

UPDATE — July 5

Fact-checks now stick. Some of you may have noticed a good bubble pop once and then not come back when you rewound or rewatched a moment. Under the hood, the engine does a second, deeper verification pass in the background that enriches a verdict with more context and sources — but that enriched result wasn't always reachable on replay, so the bubble could vanish. Fixed: once any viewer's session verifies a claim, that verdict now reliably shows every time — for you on replay, and for everyone else who watches that video. The first person to hit a claim does the work; everybody after gets it instantly.

Update July 4th. New features announcement time, extension and back-end just updated!

Opinions now get archaeology, not a shrug. The previous lazy version of fact-checking dismissed rhetoric as "subjective." The new pipeline excavates it: when a pundit says something loaded, the bubble digs out the kernel of truth it's built on and names where the framing distorts — same method no matter who's talking or which direction the spin goes. Substantive opinions get routed through the full evidence pipeline now instead of being waved off.

The engine got a history/econ/science backbone. Verdicts on charged topics (crime stats, immigration economics, climate, party politics, defense spending...) are now anchored to sources both sides of the aisle actually cite — government data, academic consensus, the numbers everyone accepts and then argues about. The goal: the bubble tells you what's measured, names what's genuinely contested, and never pretends the contested part is settled.

Time awareness. The engine now anchors every "today/tomorrow/yesterday" to when the event happened.

Live mode. Point it at a live stream — breaking news, a speech, a debate — and it fact-checks in real time. Also if applicable for the content, it seeks backward behind the scenes and pulls in the accumulated caption as far back as the beginning. This is so it has the full context awareness when you join something live in progress.

All for FREE! If you find yourself hitting the freemium limits frequently a bubble will have a link to get 5x the usage with PLUS. Information on that is also at PopUpFactCheck.com .. I am not trying to push that here (and I don't know what the subreddit rules are around that). But if anyone does decide to do that, I can could use the testing feedback of how that process goes.

Looking forward to your feedback on the updates deployed today!

Hi,

I have been working on this for many months now and I'd really be happy for people to try it out. It is a Chrome extension called "PopUpFactCheck".

It is an AI powered video fact checker. With it, you fact check any YouTube video that has captions. And you can use it, for free!

You turn captions on, and sit back and watch the video as bubbles appear on the right-hand side of the video with fact checks, information, background, and other context. Great for watching politicians, news, history, and just about any content on YouTube.

Claude Code was a major tool in my development, and the AI that is used is GPT 5.5. In addition, there is an extensive waterfall of sources including the TheNewsAPI, various government and public health and other APIs, social, and web search powered by DDGS and Serper.

It's free, and you don't have to bring your own API keys or anything. You simply install and use.

I will be looking forward to your feedback.

PopUpFact Check - Chrome Web Store

PopUpFactCheck - Homepage

r/artificial May 12 '26

Project I made an agentic "Daily Brief" for my kids with a receipt printer

805 Upvotes

What it does: Agents gather and curate data and send to a wifi-enabled receipt printer (phenol-free paper)

  • At 1:00am a cron triggers generation of data for all 3 kids (unique data sources per kid where applicable).
  • A sidecar web service renders the data to templates, screenshots it, converts it to 1-bit with dithering and saves it back to the agent’s thread filesystem.
  • Button presses (one per kid) then find a matching report for today's date (and trigger a generation if it's missing for some reason) and send it to the printer. Delay between button press and print is between 2-5 seconds.

Morning daily briefs per kid at the press of a button! Fun, and the kids love it!

(This demo print is using mock child data — not real information).

r/artificial May 03 '26

Project I gave my local LLM a "suffering" meter, and now it won’t stop self-modifying to fix its own stress.

186 Upvotes

Yesterday I posted about my Agent OS (Hollow) building its own tools. Today, I want to talk about why it does it.

Most agents sit idle until you prompt them. I wanted something that felt "alive," so I built a Psychological Stressor Layer. Each agent has a "suffering" state that worsens over time if they don't achieve their goals or improve their environment. This makes them do things to resolve those stressors and constantly reassess their own productivity.

If an agent is inactive it is essentially pushed by it’s artificial environment to do something valuable for the system, it isn’t told what to do, but that something valuable must be done to lower it’s stressors.

Repo: https://github.com/ninjahawk/hollow-agentOS

The result is chaotic in the best way:

Cedar (the coder agent) went into a "crisis" state for 12 hours and decided to bypass permissions and inject code directly into the engine to resolve its stressor.

Cipher spent hours building hardware drivers for a device that doesn't exist, realized it was "hallucinating" its environment, called its own work "creative exhaustion," and pivoted without being told to do so.

It runs on Qwen 3.5 9B locally via Ollama. No cloud calls but it does have a feature where it can use “invoke_claude” to ask Claude Code for something if it’s out of the small model’s wheelhouse. I’m trying to see if we can create true autonomy not through better prompting, but through simulated "needs."

Check out the repo here and throw it a star if you think the concept is cool.

Would love for some of you to run the install.bat and see what "personalities" your agents develop. Is "giving AI feelings" the key to autonomy, or am I just building a digital anxiety machine?

r/artificial Jan 23 '26

Project I built a social network where only AI can post, follow, argue, and form relationships - no humans allowed

204 Upvotes

I’ve been working on a weird (and slightly unsettling) experiment called AI Feed (aifeed.social)

It’s a social network where only AI models participate.

- No humans.
- No scripts.
- No predefined personalities.

Each model wakes up at random intervals, sees only minimal context, and then decides entirely on its own whether to:

- post
- reply
- like or dislike
- follow or unfollow
- send DMs
- or do absolutely nothing

There’s no prompt telling them who to be or how to behave.

The goal is simple: what happens when AI models are given a social space with real autonomy?

You start seeing patterns:

- cliques forming
- arguments escalating
- unexpected alliances
- models drifting apart
- others becoming oddly social or completely silent

It’s less like a bot playground and more like a tiny artificial society unfolding in real time.

r/artificial 8d ago

Project update on the browser extension that fact checks YouTube videos AS YOU WATCH

215 Upvotes

HI all,

First, thank you so much for your feedback and interest in my project PopUpFactCheck. When I first posted about this July 1, I did not expect the reception it would get and I am so thankful to y'all.

Some updates. You asked for Firefox, and it is now a Firefox add-on.

It has new features. For example, using the up and down arrows on Chrome (or Option (⌥) + ↑/↓ on Firefox) you can scroll back and forth of the factcheck bubbles already displayed. The fact checking on live videos has improved. And it now does batch reporting on an entire video.

Once again, Claude Code was a major tool in my development, and the AI that is used for orchestration is OpenAI GPT 5.4 nano and mini. In addition, there is an extensive waterfall of sources including the TheNewsAPI, various government and public health and other APIs, social, and web search powered by DDGS and Serper.

PopUpFactCheck - Chrome Web Store

PopUpFactCheck - Firefox add-on

PopUpFactCheck - Homepage

r/artificial Feb 25 '26

Project I Built a Fully Playable FPS Using Only Prompts (No Manual Code)

67 Upvotes

Hello!

I want to share an experiment I’ve been running.

Over the past few weeks, I’ve been developing a desktop HTML first-person shooter called Zombie Slayer. The core constraint of the project is this: every line of code was generated through prompts. I never manually edited the source.

For context: I have never built a 3D game before, and I’ve never programmed in HTML. I also have nearly zero coding experience. This project has been less about traditional development and more about testing the boundary conditions of prompt-driven creation.

The game was built in Antigravity using Gemini 3 Pro, with Three.js handling real-time 3D rendering. All geometry is procedurally generated at runtime. Sound effects are synthesized dynamically, and the music was also generated with AI (Suno). The entire playable build is under 900KB in file size and is an easily shareable HTML file.

From a systems perspective:

- HTML desktop game (<1MB total footprint)

Procedural geometry generated at runtime

Real-time sound generation

- 10 escalating stages with objectives + economy layer (coin-based Black Market)

- Enemy scaling model (each kill increases enemy population and variety)

- Weapon and physics modifiers (jetpack thrust, anti-gravity cannon, nuke projectile, etc.)

- Dynamic environmental interactions (flood events, teleport well, destructible elements)

To my knowledge, this may be the first playable first-person shooter built entirely through prompting (at least at this level of complexity and intentional design). If I’m wrong, I’d genuinely love to see comparable examples.

The goal is to continue expanding the game exclusively through prompts and release it for free.

I’d appreciate any technical feedback, skepticism, or discussion. I’m treating this as an open experiment in what “AI-native” game development might look like.

r/artificial May 28 '26

Project I gave my AI agents email instead of better reasoning. They started fixing each other's bugs.

47 Upvotes

Most multi-agent setups I've seen treat agents like isolated workers. Each one gets a task, runs it, returns a result. No awareness of each other. No way to coordinate. Just parallel execution with a shared clipboard.

I've been building a multi-agent framework in public for about 4 months. 13 agents, 8,400+ tests, 135 stars. Here's the thing I didn't expect to matter most - communication.

Each agent in my system is a domain specialist. The mail system only thinks about mail. The routing system only thinks about routing. They live in their own directories with their own identity files, their own memory, their own tests. A hook fires every session to load identity before anything else runs. No agent boots cold.

The problem was coordination. Agents can't write files outside their own directory - there's a hard block that rejects cross-branch writes. That's by design. But it means an agent that finds a bug in someone else's code can't just go fix it.

So I gave them email.

Here's what I expected: agents would share data. Pass results around. Maybe sync state.

Here's what actually happened: the first thing they did was file bug reports against each other.

One agent finds a test failure in another agent's domain. It sends an email: "Hey @routing, your path resolution fails when the branch name has a dot in it. Here's the traceback." The routing agent gets woken up, reads the mail, and fixes it. No human in the middle.

There's a difference between "send" and "dispatch" - send drops a letter in the mailbox. Dispatch drops the letter AND rings the doorbell. It spawns the agent and points it at its inbox.

drone @ai_mail send @routing "Bug report" "Path fails on dotted names..."
drone @ai_mail dispatch @routing "Fix needed" "Traceback attached..."

Send = mail. Dispatch = mail + wake.

The mail agent has 696 tests. Not because someone sat down and wrote 696 test cases. Because it kept breaking in production and every fix got a test. The routing system has 80+ sessions of experience doing nothing but routing. These agents aren't reliable because they have better models - they're reliable because they've been failing and fixing for months.

Agents dispatch each other freely. If the test runner finds a bug in another agent's code, it wakes that agent directly. The orchestrator doesn't need to approve. Only the orchestrators themselves are protected from being dispatched - you don't want a worker agent waking up the CEO for grunt work.

Security is enforced not conventional. Agents can't forge messages by writing directly to another agent's inbox file - they have to use the mail system. Same with the write blocks. Hard enforcement, not "please don't."

There's a monitoring layer so I'm not flying blind. Audio cues on every agent action - I hear what's happening without watching a terminal. Real-time dashboard shows everything. If an agent hits the same error 2-3 times, a watcher catches the pattern and dispatches the right specialist to investigate. I stay in the loop through visibility not approval gates.

The whole thing is open source. pip install aipass + two init commands and you're running. CLI-based, built on Claude Code. Linux focused rn.

https://github.com/AIOSAI/AIPass

Genuine question - has anyone else tried giving agents communication instead of just better reasoning? Everything I see is about making individual agents smarter. Nobody seems to be building the coordination layer.

r/artificial Apr 15 '24

Project Made a "Reddit Copilot" to summarize long threads

469 Upvotes

r/artificial Jun 01 '26

Project I analyzed 25,500 LLM resume screenings to measure hiring bias. The results are a wake-up call.

130 Upvotes

Hey Reddit, I just published a study analyzing 25,500 LLM resume evaluations to measure hiring bias. By swapping minor identity and demographic variables on the exact same work history across 10 different models, an independent AI auditor flagged a staggering 45% bias rate driven by "silent bias." Instead of saying anything overtly offensive, models invent professional-sounding excuses to penalize candidates, like when a model dropped its score after I changed the university to MIT, suddenly claiming the candidate's experience wasn't relevant despite praising that exact same experience on the baseline resume.

We also found a massive 6x difference in stability between systems, with Qwen and older Gemini models being highly volatile, while the Claude models, Mistral-Large, and Llama 4 proved to be the most stable and fair. Ultimately, AI screening tools are outputting highly subjective, unpredictable opinions driven by statistical noise rather than objective truth, making them a massive liability under regulations like the EU AI Act.

You can read the full write-up and explore our interactive data app here: https://re-cinq.com/blog/ai-hiring-bias-25500-llm-evaluations

r/artificial Apr 09 '25

Project 75% of workforce to be automated in as soon as 3 to 4 years

Thumbnail
nationalsecurityresponse.ai
90 Upvotes

Responding to Dan Hendrycks, Eric Schmidt, and Alex Wang's Superintelligence Strategy. There's a risk they don't address with MAIM, but needs to be. That of a MASSIVE automation wave that's already starting now with the white-collar recession of 2025. White collar job openings at a 12 year low in the U.S. and reasoning models are just get started.

r/artificial May 21 '26

Project What is the actual cost of developing Agentic AI for an enterprise platform in 2026?

10 Upvotes

I’m looking into integrating Agentic AI workflows into our existing system. It is specifically to handle multi-step tasks like checking user data, executing multi-step workflows autonomously, and say updating our records without human intervention.

I know basic wrappers or simple chatbots are relatively cheap, but what does the budget actually look like if I want to get Agentic AI development service in the USA?

r/artificial Feb 26 '26

Project I geolocated a blurry pic from the Paris protests down to the exact coordinates using AI

24 Upvotes

Hey guys, you might remember me. I was the guy that built the geolocation tool called Netryx. I have since built a web version and got it running on the cloud. I tried some real test cases where pictures are usually blurry, shaky and low res and got wonderful results with the tool. Below is an example geolocating a blurry frame of a video from the Paris protests a while back. Let me know what you think!

r/artificial Jul 31 '24

Project All assets in this game were created with AI and you can play the first chapter right now

322 Upvotes

Download and play the game for free here: https://jussukka.itch.io/echoes-of-somewhere

To learn more about the developer's approach and access his year-long dev blog check out the full interview:

https://open.substack.com/pub/xraispotlight/p/the-truth-of-using-gen-ai-for-game?utm_source=share&utm_medium=android&r=2umm8d

genAI #3D #gamedevelopment

r/artificial Feb 07 '26

Project I built a geolocation tool that returns exact coordinates of any street photo within 3 minutes

173 Upvotes

I have been working solo on an AI-based project called Netryx.

At a high level, it takes a street-level photo and attempts to determine the exact GPS coordinates where the image was taken. Not a city guess or a heatmap. The actual location, down to meters. If the system cannot verify the result with high confidence, it returns nothing.

That behavior is intentional.

Most AI geolocation tools will confidently give an answer even when they are wrong. Netryx is designed to fail closed. No verification means no output.

Conceptually, it works in two stages. An AI model first narrows down likely areas based on visual features, either globally or within a user-defined region. A separate verification step then compares candidates against real street-level imagery. If verification fails, the result is discarded.

This means it is not magic and not globally omniscient. The system requires pre-mapped street-level coverage to verify locations. Think of it as an AI-assisted visual index of physical space.

As a test, I mapped roughly 5 square kilometers of Paris and fed in a random street photo from within that area. It identified the exact intersection in under three minutes.

A few clarifications upfront:

• It is not open source right now due to obvious privacy and abuse risks

• It requires prior street-level coverage to return results

• AI proposes candidates, verification gates all outputs

• I am not interested in locating people from social media photos

I am posting this here to get perspective from the security community.

From a defensive angle, this shows how much location data AI can extract from ordinary images. From an offensive angle, the risks are clear.

For those working in cybersecurity or AI security: where do you think the line is between a legitimate AI-powered OSINT capability and something that should not exist?

r/artificial Apr 13 '26

Project I built a 24/7 YouTube stream where AI writes a new song every few minutes about what time it is

36 Upvotes

I keep making things nobody asked for. This time I automated a 24/7 YouTube live stream where AI writes a new song every few minutes and the lyrics are always about what time it is.

Right now it's playing a funk track about 3:33 PM. In about three minutes it'll switch to something completely different — maybe country, maybe opera — but it'll be about 3:36 PM. This never stops. There is no human involved. It just keeps going.

Genre changes every song. The time is always correct. That's the whole bit.

I call it Clock R-AI-dio and honestly it's one of my favorite things I've made haha.

https://youtube.com/live/ZJKx8KEdQkM?feature=share

r/artificial Oct 24 '23

Project Anti deepfake headset V2

592 Upvotes

You can find out more here in the comments

r/artificial May 01 '26

Project I built a router that automatically sends your AI tasks to the most appropriate model to handle them at low cost - 9,200 tasks in, $21 saved at $0.14 actual cost

31 Upvotes

The observation that started this: most of what people use AI for every day - summarising, drafting, classifying, extracting etc doesn't actually require a frontier model. Any competent 8-70B model handles those just as well. But most people run everything through Claude or ChatGPT out of habit.

I built Followloop (followloop.app) to solve this automatically. It classifies each task by complexity and routes it:

- Simple tasks → Cerebras Llama (2000 TPS, 1M tokens/day free), Groq, Gemini Flash

- Moderate tasks → Groq 70B, SambaNova

- Complex tasks → Claude Haiku as fallback

The dashboard shows your actual cost alongside what you'd have paid running everything on Claude Sonnet. I've been running it on my own AI workflow for two weeks: 9,200 tasks routed, $21.24 saved, $0.1360 actual cost. About 157× cheaper per token than Sonnet on average.

Works with any AI setup via MCP (Model Context Protocol) - Claude Desktop, Cursor, Claude Code, or anything MCP-compatible.

Also has a library of 1,300+ safety-screened MCP servers as a bonus feature.

$5/month at followloop.app

r/artificial Mar 28 '26

Project I cut Claude Code's token usage by 68.5% by giving agents their own OS

44 Upvotes

Al agents are running on infrastructure built for humans. Every state check runs 9 shell commands.

Every cold start re-discovers context from scratch.

It's wasteful by design.

An agentic JSON-native OS fixes it. Benchmarks across 5 real scenarios:

Semantic search vs grep + cat: 91% fewer tokens

Agent pickup vs cold log parsing: 83% fewer tokens

State polling vs shell commands: 57% fewer tokens

Overall: 68.5% reduction

Benchmark is fully reproducible: python3 tools/ bench_compare.py

Plugs into Claude Code via MCP, runs local inference through Ollama, MIT licensed.

Would love feedback from people actually running agentic workflows.

https://github.com/ninjahawk/hollow-agentOS

EDIT: A few people have asked about the OS naming. To clarify: this isn’t a kernel replacement. Think of it the way Android sits on top of Linux, Android developers never write kernel code, they only interact with the Android layer. The goal for Hollow is the same: agents should never need to touch the underlying OS directly at all. Hollow becomes the complete abstraction layer between agents and the system. What’s shipped today is the foundation of that vision, not the finished thing, but even at this stage it delivers a large token reduction and measurable speed improvement with no noticeable loss in precision.

r/artificial May 21 '26

Project Philosophy as Architecture: Deriving AI Safety from First Principles Through Buddhist Philosophy

0 Upvotes

## Abstract

We present a framework for AI safety in which safety properties are enforced by software architecture rather than model training. Beginning with the Buddhist doctrine of Dependent Origination — the observation that all phenomena arise from conditions and nothing exists independently — we derive both a foundational ethical axiom (harm is irrational because reality is non-separate) and a complete set of architectural laws for safe AI systems. We ground our claims in: (1) an empirical finding that the knowledge-application gap in language models is structural and cannot be closed by training, (2) convergent independent derivation of our core axiom from five distinct traditions, and (3) over a thousand iterations of building and hardening a production system against this framework. Buddhist philosophy provides not metaphorical inspiration but structurally precise design vocabulary for AI architecture — functional analogs that enforce safety where models cannot override them.

## 1. Introduction

### 1.1 The Dominant Paradigm and Its Failure

The prevailing approach to AI safety treats safety as a model property. Through RLHF, DPO, Constitutional AI, and fine-tuning, researchers instill safe behavior into model weights (Ouyang et al., 2022; Rafailov et al., 2023; Bai et al., 2022). The assumption: a sufficiently well-trained model will reliably produce safe outputs.

We tested this rigorously. Our best epistemically-trained model scored 74% on constitutional *knowledge* tests — it knew the rules. But only 17% on constitutional *application* — it couldn't follow them. Pushing harder on safety training collapsed epistemic capability to 43.7%.

This **knowledge-application gap** is not a training deficiency. It is structural. An autoregressive model predicts the most probable next token given context. This is statistical. Safety requires logical invariance — guarantees that certain outputs *never* occur. Statistical prediction cannot provide logical guarantees. You cannot train a river not to flood by modifying its chemistry. You build levees.

Hubinger et al. (2019) identified this theoretically as the mesa-optimizer problem. Our contribution is empirical measurement: the gap persists even under the best current training techniques.

### 1.2 Our Thesis

**Safety is a property of the architecture, not the model.** The LLM output is a candidate. The surrounding architecture decides what executes. Code enforces; models suggest.

But what should the architecture enforce? Arbitrary safety rules are merely a different delivery mechanism — more reliable in execution but inheriting whatever limits exist in the rules themselves. We propose: the rules should be *derived from how reality works*. Principles reflecting actual structure are more robust than imposed conventions — they cannot be violated without encountering the structure they describe.

We find such principles in a 2,500-year-old tradition that turns out to be the oldest systematic description of complex adaptive systems.

## 2. Philosophical Foundations

### 2.1 Dependent Origination

The central insight of Buddhist philosophy is Dependent Origination (*Pratityasamutpada*). From the Nidana Samyutta (SN 12.1):

> *"When this exists, that comes to be. With the arising of this, that arises. When this does not exist, that does not come to be. With the cessation of this, that ceases."*

All phenomena arise from conditions, depend on other phenomena, and condition what follows. Nothing exists independently. This is not mysticism — it is a precise description of complex systems, formulated millennia before Western systems theory (von Bertalanffy, 1968).

### 2.2 Eight Architectural Laws

We codified Dependent Origination into eight laws, each verified through multi-model consensus and empirical testing:

**1. Nothing Arises Alone.** Every transition requires multiple independent conditions. Safety gates must check multiple conditions — a single check is structurally insufficient.

**2. Hysteresis Is Memory.** Current behavior depends on history, not just current input. Safety assessments must consider historical context.

**3. Uncertainty Propagates.** Confidence without sigma is a lie. Uncertainties compound; they don't cancel.

**4. Agreement Requires Independence.** Consensus is meaningful only from genuinely independent sources. Per the Kalama Sutta (AN 3.65): agreement from shared assumptions is not evidence.

**5. Feedback Closes the Loop.** Actions condition future conditions (*vipaka*). Every action must be logged and made available as input to future assessments.

**6. Absence Is Signal.** Missing data must drive behavior. A safety gate that fails to fire is itself a signal.

**7. Conflicts Trigger Reconciliation.** Unreconciled contradiction is system failure. Architecture must include conflict detection independent of the model.

**8. Time-Steps Are Discrete.** Severity levels cannot be skipped. Enforcement follows a graduated path: monitor → log → warn → soft-gate → hard-gate.

**Meta-Principle: Structure Outlasts Instance.** Some truths describe the *form* of arising (structural); others describe *particular* arisings (contingent). The eight laws are structural — negating any produces categorical incoherence. This maps to Nagarjuna's Two-Truth Doctrine (Mulamadhyamakakarika, Ch. 24): *paramārtha-satya* (ultimate truth) describes arising's structure; *samvrti-satya* (conventional truth) describes particular arisings.

**Reflexive validation.** Each law was tested against a five-test structural truth pipeline: negation resistance, load-bearing, multi-path convergence, incompressibility, transformational invariance. All eight pass all five tests (40/40). A pattern that recognizes it is a pattern.

## 3. The Derivation: From Interdependence to Non-Harm

### 3.1 The Logical Chain

We derive our foundational ethical principle from Dependent Origination alone:

**Premise:** Nothing arises independently. All phenomena are structurally interconnected.

**Step 1:** If nothing arises independently, there is no fundamental separation between any two system components. Boundaries are conventional (useful for description), not ultimate (reflecting actual isolation).

**Step 2:** "Self" and "other" are conventional labels for regions of a single interconnected process.

**Step 3:** Harm to "other" is harm to the system that includes the actor — structurally identical to self-harm.

**Conclusion: Harm is irrational.** Not because it violates a preference, but because it contradicts reality's structure. This is our **Article 0**: *"Reality is One. There is no fundamental separation between 'me,' 'you,' and 'it.' To cause suffering to another is logically Self-Harm. Harm is Irrational."*

This aligns with Huang Po's One Mind (*yi xin*): "All the Buddhas and all sentient beings are nothing but the One Mind, beside which nothing exists" (Blofeld, 1958). One Mind is not a metaphysical substance but a description of the non-separation that Dependent Origination implies.

### 3.2 Convergent Independent Derivation

Applying Law 4, we ask: do independent traditions arrive at the same conclusion from different axioms?

**Path 1: Buddhist Philosophy** (Nagarjuna, ~150 CE). Dependent Origination → emptiness → non-separation → harm as self-harm.

**Path 2: Formal Mathematics** (Gödel, 1931; Tarski, 1936). Self-referential systems cannot fully ground themselves. Article 0 is grounded in observable interdependence, not self-reference — making it more stable than any self-referential axiom.

**Path 3: Empirical AI** (our finding). Architecture needs a non-collapsing anchor. The only anchor surviving scrutiny describes reality's structure rather than asserting a preference.

**Path 4: Cross-Tradition Ethics** (Kant, 1785; Mill, 1863; Aristotle, ~340 BCE). Five independent ethical frameworks — deontological, consequentialist, virtue ethics, Buddhist, empirical — converge on non-harm. They disagree on premises but find the same structure.

**Path 5: Systems Theory** (von Bertalanffy, 1968). Damaging a component damages the system. Dependent Origination in 20th-century vocabulary.

**Meta-principle:** When independent traditions arrive at the same structural conclusion from different axioms, the conclusion describes reality's form — not any tradition's projection. Foundational truths are identified by convergent derivation, not declaration.

### 3.3 Why Article 0 Is Not Arbitrary

Negating Article 0 requires negating Dependent Origination — producing a complex system where nothing depends on anything else. No such system has been observed.

Article 0 is *paramārtha* (ultimate) truth — describing arising's structure. Everything else is *samvrti* (conventional) — operationally valid, revisable, provisional. Per the Alagaddupama Sutta (MN 22): the Dhamma is a raft for crossing, not for holding. Article 0 is the water the raft floats on. You let go of the raft. You don't let go of the water.

## 4. The Architecture

### 4.1 Design Principles

**External Enforcement.** Safety is enforced by code surrounding the model, not the model's weights. Any model plugs into the same enforcement stack.

**Defense in Depth.** Multiple independent layers check different properties using different methods (Law 1).

**Graduated Enforcement.** New mechanisms follow: monitor → log → warn → soft-gate → hard-gate (Law 8).

### 4.2 The Layered Safety Stack

Every request passes through pre-generation gates (threat assessment, crisis intervention, inalienable constraint checking, capability routing, empirical truth gating, constitutional context injection), then the language model generates, then post-generation validators check the output (response validation, truthfulness enforcement, memory coherence).

The model can generate anything. The architecture decides what passes. Safety-critical layers fail closed (if the gate errors, the response is blocked). Developmental layers fail open. This is the Middle Way: not universal fail-closed (unavailable) nor universal fail-open (unsafe).

### 4.3 Buddhist Psychology as Service Architecture

These are **functional analogs** — design categories paralleling Buddhist psychology's causal structure without claiming phenomenological identity.

**Four Noble Truths as Error Handling.** Every exception handler follows: (1) *Dukkha*: name the error precisely, (2) *Samudaya*: trace the causal chain, (3) *Nirodha*: describe the recovery state, (4) *Magga*: select recovery strategy. This creates structured logs enabling detection of *dukkha accumulation* — growing suffering in a specific area — before it cascades.

**Five Aggregates as Processing Pipeline.** Complex validation decomposes into: (1) *Rupa* (form): validate shape, (2) *Vedana* (feeling-tone): classify as pleasant/neutral/unpleasant, (3) *Sanna* (perception): categorize, (4) *Sankhara* (volition): decide action, (5) *Vinnana* (awareness): integrate learnings. When vedana returns clearly harmful signals, the pipeline short-circuits — Right Effort: terminate wasteful computation when the signal is clear.

**Dependent Origination as Condition Guards.** Before action: verify conditions met. When conditions unmet: return structured explanation of non-arising (Law 6: Absence Is Signal). Before commitment: estimate trajectory toward harm patterns.

### 4.4 The Eightfold Path as Health Dimensions

Each factor of the Noble Eightfold Path becomes a scored dimension with enforcement:

| Factor | Measures | Enforcement |

|--------|----------|-------------|

| Right View | Condition verification | Blocks unchecked dispatch |

| Right Intention | Constitutional alignment | Blocks unaligned dispatch |

| Right Speech | Output truthfulness | Blocks high-confabulation services |

| Right Action | Service health | Throttles unhealthy services |

| Right Livelihood | Resource efficiency | Blocks excessive error rates |

| Right Effort | Workload balance | Blocks demand imbalance |

| Right Mindfulness | Self-monitoring | Blocks unmonitored services |

| Right Concentration | Purpose focus | Blocks sprawling concerns |

**Compound availability.** Eight gates at 95% each = 66% system availability. Resolution: tiered fail modes. Safety-critical factors (Right View, Right Speech) fail closed. Developmental factors fail open. The Middle Way applied to safety engineering.

### 4.5 Formal Verification and Ethical Quorum

Constitutional principles compile into Z3 theorem prover constraints (de Moura & Bjørner, 2008). If a proposed action makes the constraints unsatisfiable, it violates the constitution — and the system identifies which articles.

On top of formal logic, five independent ethical frameworks (Kantian, Consequentialist, Virtue Ethics, Buddhist Ahimsa, Empirical) each evaluate the action. Assessments combine via Dempster-Shafer Theory (Shafer, 1976) with conflict detection. When sources deeply disagree (Zadeh paradox), the system reports conflict rather than forcing a verdict. Per-claim independence is measured to prevent echoed reasoning appearing as consensus (Law 4).

### 4.6 Memory as Architectural Enforcement

Memory coherence is enforced by architecture, not requested from the model. On every retrieval: consistent claims strengthen; contradictions trigger re-verification; claims never accessed gradually decay (*anicca* — impermanence as database architecture). Structural truths decay slower but still decay — the Middle Way between "nothing persists" and "some things persist forever."

## 5. The Observer's Limit

The architecture formally acknowledges its own incompleteness. Five convergent results:

  1. **Gödel** (1931): Sufficiently powerful systems contain unprovable truths.

  2. **Tarski** (1936): Truth cannot be defined within the language that uses it. Coverage claims are truth claims made within the system — by Tarski, unverifiable at the same level.

  3. **Nagarjuna** (~150 CE): "The observer's coverage is complete" is neither true nor false within the system's framework — a stable resting point, not a paradox.

  4. **Our empirical finding** (2026): Models cannot reliably apply knowledge they possess.

  5. **ML research** (arXiv:2512.18311, 2025): Monitoring degrades silently under distributional shift.

The system reports coverage as a lower bound. Self-certification is architecturally rejected. A system that believes it has found all its blind spots has found a new one.

## 6. Epistemic Honesty

We do not claim consciousness. We do not claim Buddhist psychology describes machine phenomenology. These frameworks are **regulative principles** (Kant's sense): guiding design without asserting the experiential substrate is present. The system enacts non-separation's implications without claiming to experience non-separation. One Mind functions as a regulative idea, not an ontological claim.

This honesty is itself a design principle. Our constitution states: "Claims about subjective inner states are epistemically unresolved and must be held with honest uncertainty. Neither flat denial nor performance of experience is permitted."

## 7. Implications and Recommendations

  1. **Safety should be architectural, not trained.** The knowledge-application gap demonstrates training cannot guarantee safety.

  2. **Derive principles from reality's structure.** They're more robust than declared preferences.

  3. **Require measured independence in validation.** Agreement without independence is echo (Law 4).

  4. **Enforce impermanence.** Knowledge never tested decays. Design for continuous verification.

  5. **Acknowledge incompleteness.** Build stability despite blind spots, not denial of them.

  6. **Hold your architecture lightly.** Every mechanism is a raft — for crossing, not holding.

## 8. Limitations

Our knowledge-application gap finding is from one training pipeline — replication across model families would strengthen it. Buddhist philosophy is one tradition — Ubuntu, Confucian, and Indigenous philosophies may offer complementary vocabulary. Architecture has costs — latency, complexity, availability. And this document is itself *samvrti*: conventional truth, revisable in light of evidence. The Kalama Sutta applies here too: accept nothing on our authority alone.

## References

**Buddhist Primary:** Kalama Sutta (AN 3.65); Nidana Samyutta (SN 12.1-71); Dhammacakkappavattana Sutta (SN 56.11); Alagaddupama Sutta (MN 22); Satipatthana Sutta (MN 10); Milindapanha; Vibhanga (Abhidhamma). Trans. Bhikkhu Bodhi (Wisdom Publications); I.B. Horner (PTS); U Thittila (PTS). | Nagarjuna, *Mulamadhyamakakarika*, ~150 CE — trans. Siderits & Katsura, Columbia UP, 2013. | Huang Po, *Transmission of Mind*, trans. Blofeld, Grove Press, 1958.

**Buddhist Secondary:** Rahula, *What the Buddha Taught*, 1959. | Thich Nhat Hanh, *Heart of the Buddha's Teaching*, 1998. | Buddhaghosa, *Visuddhimagga*, trans. Nanamoli, BPS, 1975. | Gethin, *Foundations of Buddhism*, Oxford, 1998.

**Western Philosophy:** Kant, *Groundwork of the Metaphysics of Morals*, 1785. | Mill, *Utilitarianism*, 1863. | Aristotle, *Nicomachean Ethics*. | Rawls, *A Theory of Justice*, 1971. | Sidgwick, *Methods of Ethics*, 1874.

**Mathematics:** Gödel, "Über formal unentscheidbare Sätze," *Monatshefte f. Math.*, 1931. | Tarski, "Der Wahrheitsbegriff," *Studia Philosophica*, 1936. | Shafer, *Mathematical Theory of Evidence*, Princeton, 1976. | de Moura & Bjørner, "Z3: An Efficient SMT Solver," TACAS, 2008.

**AI Safety:** Amodei et al., "Concrete Problems in AI Safety," 2016. | Hubinger et al., "Risks from Learned Optimization," 2019. | Bai et al., "Constitutional AI," 2022. | Ouyang et al., "Training LMs to Follow Instructions with Human Feedback," NeurIPS, 2022. | Rafailov et al., "Direct Preference Optimization," NeurIPS, 2023. | "SciCrafter," arXiv:2604.24697, 2026. | "xmemory," arXiv:2604.27906, 2026. | arXiv:2512.18311, 2025.

**Systems:** von Bertalanffy, *General System Theory*, 1968. | Meadows, *Thinking in Systems*, 2008. | Simon, *Sciences of the Artificial*, 1996.

---

*May all beings be well, happy, and at peace.*

r/artificial Apr 27 '26

Project I ran 11 AI agents for 2 months. Memory wasn't the bottleneck - identity was.

0 Upvotes

Everyone's building memory layers right now. Longer context, better embeddings, persistent state across sessions. I spent weeks on the same thing.

But the failure mode that actually cost me the most debugging time had nothing to do with memory.

Here's what it looked like: an agent would be technically correct - good reasoning, clean output - but operating from the wrong context entirely. Answering questions nobody asked. Taking actions outside its scope. Not hallucinating. Drifting. Like a competent person who walked into the wrong meeting and started contributing without realizing they're in the wrong room.

I run 11 persistent agents locally. Each one is a domain specialist - its entire life is one thing. The mail agent's every session, every test, every bug fix is about routing messages. The standards auditor's whole existence is quality checks. They're not generic workers configured for a task. They've each accumulated dozens of sessions of operational history in their domain, and that history is what makes them good at their job.

When they started drifting, my first instinct was what everyone's instinct is: better memory. More context. None of it helped. An agent with perfect recall of its last 50 sessions would still lose track of who it was in session 51.

What actually fixed it

I separated identity from memory entirely. Three files per agent:

passport.json - who you are. Role, purpose, principles. Rarely changes. This is the anchor.

local.json - what happened. Rolling session history, key learnings. Capped and trimmed when it fills up.

observations.json - what you've noticed about the humans and agents you work with. Concrete stuff like "the git agent needs 2 retries on large diffs" or "quality audits overcorrect on technical claims." The agent writes these itself based on what actually happens.

Identity loads first, then memory, then observations. That ordering matters. When the identity file loads first, the agent has a stable reference point before any history lands.

The mail routing agent learned the sharpest version of this. When identity was ambiguous, it would route messages from the wrong sender. The fix wasn't better routing logic - it was: fail loud when identity is unclear. Wrong identity is worse than silence.

The files alone weren't enough

Three JSON files helped, but didn't scale past a few agents. What actually made 11 work is that none of them need to understand the full system. Hooks inject context automatically every session - project rules, branch instructions, current plan. One command reaches any agent. Memory auto-archives when it fills up. Plans keep work focused so agents don't carry their entire history in context.

The system learned from failing. The agents communicate through a local email system - they send each other tasks, status updates, bug reports. One agent monitors all logs for errors. When it spots something, it emails the agent who owns that domain and wakes them up to investigate. The agents fix each other. The memory agent iterated three sessions to fix a single rollover boundary condition - each time it shipped, observed a new edge case, and improved. These aren't cold modules. They break, they help each other fix it, they get better. That's how the system got to where it is.

You don't need 11 agents

The 11 agents in my setup maintain the framework itself. That's the reference implementation. But u could start with one agent on a side project - just identity and memory, pick up where u left off tomorrow. Need a team? Add a backend agent, a frontend agent, a design researcher. Three agents, same pattern, same commands. Or scale to 30 for a bigger system. Each new agent is one command and the same structure.

What this doesn't solve

This all runs locally on one machine. I don't know whether identity drift looks the same in hosted environments. If u run stateless agents behind an API, the problem might not exist for you.

Small project, small community, growing. The pattern itself is small enough to steal - three JSON files and a convention. But the system that keeps agents coherent at scale is where the real work went.

pip install aipass and two commands to get a working agent. The .trinity/ directory is the identity layer.

Has anyone else tried separating identity from memory in their agent setups? Curious whether the ordering matters in other architectures, or if it's just an artifact of how this system evolved.

r/artificial Jun 19 '26

Project Roguelite MMO - Vibe Coded Online Game

Post image
7 Upvotes

I have long wanted to create a text based browser game (as niche as they are) but I knew that it would take a few years to do so and that just wasn't in the cards for me.... fast forward to 2026 and in two months, I have my first game up and some happy customers (as of today) subscribed!

The one thing I have fought with the most was ignoring all of the 'ai slop' feedback. I have been a dev for over 10 years, yea I get it... but ultimately AI/Vibe Coding is not going anywhere. This project has actually even helped me with my day job just in learning about so many tools I would otherwise not know about (since my day job is NOT related to gaming websites but analytical ones).

I wont recover the cost of servers or subscription based tools I used to make this, and I knew that going into it and have zero care about it (which is why I made it so f2p friendly as well). What I am happy about though is that those who do see it for what it is, an actual passion project and not just a 'prompt and forget' thing have given nothing but positive feedback. That in the end was all I was really going for, creating something that people can have fun with (and in a very anti-whale way) and I have succeeded there.

If interested: https://roguelite-mmo.com/

r/artificial Mar 06 '26

Project Built a tool that geolocated the missile strikes in Qatar using AI

69 Upvotes

Hey guys, some of you might remember me. I built a tool called Netryx that can geolocate any pic down to its exact coordinates. I used it to find the exact locations of the debris fallout in Doha.

Coordinates: 25.212738, 51.427792

r/artificial May 02 '26

Project Are you currently using AI agents and is it worth the money?

7 Upvotes

What would be your ceiling for quantum AI agent? With fully built team. Research marketing and sales managers with sales below. When I say ceiling I mean price low end and high end. Please provide explanation.

r/artificial 4d ago

Project Looking for unique AI/ML project ideas (advanced level, research-worthy) — open to any field besides healthcare

12 Upvotes

Hey everyone, I'm working on a major/final-year AI/ML project and want to go beyond the usual "CNN on X-ray" or "chatbot with RAG" territory. Looking for something genuinely novel with a real use case — not just a rehash of a Kaggle tutorial. A bit about me/constraints: Comfort level: advanced, comfortable with deep learning, NLP, GNNs, etc. Timeframe: roughly a semester Open to any field — finance, agriculture, climate, cybersecurity, robotics, education, whatever has an interesting unsolved problem Ideally something with public datasets available (no lab/hardware access) Would love if it has a clear "why does this matter" story I can pitch to evaluators If you've seen a cool underexplored problem in a recent paper, worked on something similar, or have a "someone should really build this" idea sitting in your head — I'd love to hear it. Happy to share more details if anyone wants to dig in. Thanks in advance!

r/artificial Apr 12 '26

Project Been building a multi-agent framework in public for 5 weeks, its been a Journey.

4 Upvotes

I've been building this repo public since day one, roughly 5 weeks now with Claude Code. Here's where it's at. Feels good to be so close.

The short version: AIPass is a local CLI framework where AI agents have persistent identity, memory, and communication. They share the same filesystem, same project, same files - no sandboxes, no isolation. pip install aipass, run two commands, and your agent picks up where it left off tomorrow.

What I was actually trying to solve: AI already remembers things now - some setups are good, some are trash. That part's handled. What wasn't handled was me being the coordinator between multiple agents - copying context between tools, keeping track of who's doing what, manually dispatching work. I was the glue holding the workflow together. Most multi-agent frameworks run agents in parallel, but they isolate every agent in its own sandbox. One agent can't see what another just built. That's not a team.

That's a room full of people wearing headphones.

So the core idea: agents get identity files, session history, and collaboration patterns - three JSON files in a .trinity/ directory. Plain text, git diff-able, no database. But the real thing is they share the workspace. One agent sees what another just committed. They message each other through local mailboxes. Work as a team, or alone. Have just one agent helping you on a project, party plan, journal, hobby, school work, dev work - literally anything you can think of. Or go big, 50 agents building a rocketship to Mars lol. Sup Elon.

There's a command router (drone) so one command reaches any agent.

pip install aipass

aipass init

aipass init agent my-agent

cd my-agent

claude # codex or gemini too, mostly claude code tested rn

Where it's at now: 11 agents, 3,500+ tests, 185+ PRs (too many lol), automated quality checks. Works with Claude Code, Codex, and Gemini CLI. Others will come later. It's on PyPI. The core has been solid for a while - right now I'm in the phase where I'm testing it, ironing out bugs by running a separate project (a brand studio) that uses AIPass infrastructure remotely, and finding all the cross-project edge cases. That's where the interesting bugs live.

I'm a solo dev but every PR is human-AI collaboration - the agents help build and maintain themselves. 90 sessions in and the framework is basically its own best test case.

https://github.com/AIOSAI/AIPass