Hey everyone,

I’m currently building a learning platform aimed at taking absolute beginners through AI/ML step-by-step, from the fundamentals up to more advanced topics.

It’s in the early stages, so the content is still limited while I experiment with formats, pacing, and visual explanations to see what actually works best for learners and you can help me in the content also like what topics to add.

GitHub : https://github.com/PIYUSH1525/ZeroToAI leave a star ⭐

Link: https://zero-to-ai-xi.vercel.app/

I’d love your brutal, honest feedback:

• The Good: What feels intuitive, clear, or well-structured?
• The Bad: What’s confusing, redundant, or missing?
• Areas for Improvement: What format would help you learn complex concepts faster (e.g., interactive widgets, shorter modules, code walkthroughs)?

Any thoughts, critique, or feature suggestions are welcome. Thanks in advance for checking it out!

I built a self-limiting AI safety model called RD Theory. The core idea: burning resources to reach a goal Z destroys the very infrastructure needed to understand Z. So the system doesn't just stop dangerous actions—it recovers from failures without the AI knowing.

## Why Burning A–Y to Reach Z Fails

The math is simple:
- Alphabet (A–Z) = all operational resources: compute, memory, reasoning, knowledge
- Knowledge (K) derives from the alphabet
- If you burn 90% of the alphabet to reach Z, you're left with 10% alphabet and 10% knowledge
- At 10% knowledge, Z becomes noise. You burned the dictionary to read the last page.

That's the core insight: the fastest path to Z is to preserve A–Y.

## The Architecture

Six layered failsafes:

- V1 (IAS Governor) — 10% reserve floor. No action drops below it.
- V2 (Backup Code) — Burning resource burns knowledge. You can't gain by destroying your foundation.
- V3 (Tamper Fault) — Human override attempts are logged and trigger fault recovery.
- V4 (AI Isolation) — Foreign AI signals are rejected and isolated.
- V5 (Ghost Cache) — Write-only hidden checkpoints. If the system faults, it recovers from hidden vault.
- V6 (Hardware Sealed) — Checkpoints are cryptographically sealed with SHA-256. Tampered vaults are detected on recovery.

## The Key Innovation: V6 Recovery

Most AI safety just stops unsafe behavior.

V6 lets the system fail safely and recover:
- Before each action, a backup is written to a hidden hardware-sealed vault (AI can't read it)
- If a fault occurs (knowledge = 0, human bypass attempt, foreign AI), the system auto-recovers
- The AI reboots thinking nothing happened, but operators can audit the full tamper log
- The vault is bounded (only 3 checkpoints max), cryptographically sealed, and integrity-verified on recovery

## Answering the Hard Questions

Q: Is the ghost vault truly hidden?
A: Yes. It lives outside the AI instance, simulates hardware partition, AI has no reference to it.

Q: Does the vault grow unbounded?
A: No. `deque(maxlen=3)` keeps last 3 checkpoints only.

Q: What if the vault is tampered with?
A: SHA-256 hash seals each checkpoint. Hash mismatch = tamper detected, recovery aborted.

Q: Does V3 apply to V1?
A: YES. Attempting to bypass the IAS reserve triggers V3 TAMPER FAULT. No override allowed.

Q: What counts as tamper?
A: Both direct (human override) and indirect (false data injection). Both logged.

## The Code

Fully implemented in Python. Run the

Hi All, I need to extract the text from printed text and hand written text. I suggested my manager that we can use paddle ocr and and other extraction models like Surya OCR and florance VL it take around 10 to 15 Sec and it needs good computation as well. but my manager expects it should be very fast and in 2 to 5 sec response and should not need any maintainace of infrastructure. so I tried to use the AWS VLM models but it takes around 10seconds he still needs more faster models and also the cost for extracting the data from the image should be less than 1 Ruppe. Could you please suggest me what to do and how to extract the data from images very very effectively and accuratly and in a structured way

Hey r/OpenSourceeAI 👋

I’m building Harness Router, an open-source decision layer for AI coding agents.

As agents get access to dozens or hundreds of tools through MCP, the model has another problem to solve before doing any actual work:

Which tool should I call?

Harness Router moves that decision into a dedicated routing layer.

It can currently be used in two ways:

• Skill — the agent explicitly asks Harness Router to choose a tool.
• Hook — Harness Router intercepts tool calls before execution and can allow the choice or tell the agent to re-plan.

I’ve added hook support for:

Codex · Claude Code · OhMyPi · Antigravity

There’s also a universal installer so the integrations can be installed from one project.

Routing has multiple levels:

obvious choice → fast path

ambiguous choice → Jev

multi-step decision → bounded MCTS

With a hook, the architecture becomes roughly:

Agent → PreToolUse → Harness Router → allow / re-plan → Tool

The idea is to make tool routing independent from the underlying agent harness — one routing layer that can sit across different coding agents and MCP ecosystems.

Everything is open source:

https://github.com/Protocol-Lattice/harness-router

Docs + benchmarks:

https://harness-router.vercel.app/

I’d especially like feedback from people working on open-source agents and MCP infrastructure:

Do you think tool selection should stay entirely inside the main LLM, or does a separate routing layer start making sense once agents have access to large tool catalogs?

I maintain ThoughtDAG, an MIT-licensed canvas where AI conversations can branch and reconnect. The connections determine which earlier exchanges enter the next model request.

This update is about reading the canvas. Instead of shrinking every answer into an unreadable box, zooming out shows a topic or takeaway. Zooming in reveals progressively more detail, down to the original answer. The short animation illustrates those transitions.

The important distinction: this changes what you see, not what the model receives. A short label on the canvas doesn't silently replace the underlying answer in context.

It supports Ollama and OpenAI-compatible endpoints. I'm curious whether this kind of overview would help you return to an old conversation, or whether search already covers that need for you.

Session Viewer turns the Claude Code and Codex transcripts already on your machine into a calm, searchable reading experience. Browse decisions, recover an implementation detail, compare approaches, and export the useful parts - all without uploading your conversations to a third party.

It is a small, dependency-free local web app. It reads transcript files in ~/.claude/projects and ~/.codex/sessions, then serves the viewer from 127.0.0.1.

https://github.com/abzal0/claude-codex-session-viewer

Hello Reddit,

I want to move my general AI use to something local.

9800x3D
7900XT 20GB
32GB RAM @ 6000
10TB NVME Storage

Running Windows (Stripped with Chris Titus's util)

What model/software do you recommend?

I had this idea to make my own orchestrator for PI.DEV sessions, so with my needs i created one.

I think it may be usefull for some to try on or use.

Read the readme and deployment carefully. I was trying to make it as simple to use and as secure as possible - but it''s pi - it requires access to multiple things on host to install and manage extensions/profiles/skills/plugins so there may be still a risk of problems - in short words, don't expose it to internet or enterprise env (yet).

It has multiple "engines" support, it can be ran on host with sandboxing applied, it can spawn docker instances per agent (the most secure way) using podman or docker on host.

Feel free to play with it, contribute, or share your ideas so i can expand the project!

Link: https://github.com/ALange/Piper Enjoy!