r/AIDeveloperNews • • Jul 30 '26

I built the largest AI modely by parameter count in Hugging Face

Post image
0 Upvotes

I built leviathan-19t on a laptop with only 344GB of spare storage. It's literally filled with 0's but it's now the largest model by parameter count.

In order to achieve this, because the model would have taken up about 9TB of storage, I built it in 25 shard batches, uploaded the shards, and then pruned them locally. I will never be able to run this at home.

The model card is here: https://huggingface.co/VickM/leviathan-19t

And code repo here: https://github.com/VickM12/leviathan/tree/main


r/AIDeveloperNews • • Sep 18 '26

Jev is changing the game again!

23 Upvotes

Not sure if you guys have seen this but this is the most exciting thing I’ve seen in a while. Lots of stuff out there from people who got invited early but this is a massive game changer.

Not everything requires a language model. Jev allows you to create the rules for decision making. And only when you need a language model do you call one.

Insanely fast. Insanely cheap. Probably top 3 of things exciting me, and likely number 1.

https://typesafe.ai/blog/introducing-system-one-models-and-jev


r/AIDeveloperNews • • Jun 28 '26

Ornith 1.0: Local AI That Beats GPT-5.5 at Coding (Free & Private)

Thumbnail
youtu.be
1 Upvotes

r/AIDeveloperNews • • May 17 '26

I built a self-evolving AI kernel that mutates its own architecture. MIT-licensed, runs on CPU.

1 Upvotes

FLUX is an open-source Python kernel that orchestrates local language models (via Ollama) into a self-modifying ecosystem. It's not a wrapper — it's an evolutionary substrate.

**What it does:**

- An **Attractor** receives a question and generates an answer using a fast model (TinyLlama).

- A **Judge** evaluates the answer on a 0–1 scale. - If confidence drops below 1/φ (≈0.618, the golden ratio), the **Mutation Engine** triggers.

- A **MetaDesigner** (powered by Hermes 3 or DeepSeek-Coder) writes a new `.flux` ecosystem file — a formal grammar for describing cognitive architectures — which gets parsed, tested, and applied if it improves performance.

- A **Growth Supervisor** monitors stability and transitions the kernel from GROWTH to PRODUCTION.

**What's different:**

- It mutates its own structure, not just model weights. - It has memory (confidence history with EMA).

- It uses a custom language (`.flux`) with a Lark parser — not YAML, not JSON.

- It runs on modest hardware: I tested it on a Xeon without AVX2, 20 GB RAM. No GPU.

**The companion novel:**

There's also a novel (Italian + English, CC BY-NC-SA 4.0) that tells the story of a man who finds this exact kernel running on a forgotten server. If you read the novel, you can compile the kernel and everything connects. The novel is the manual.

**Repo:**

[github.com/flux-genotype/nodo_zero](https://github.com/flux-genotype/nodo_zero) **Licenses:** Kernel = MIT. Novel = CC BY-NC-SA 4.0.

Happy to answer questions about the architecture, the mutation logic, or the `.flux` grammar.


r/AIDeveloperNews • • Oct 03 '26

Wappy - I wanted a WhatsApp AI agent I could run locally, so I built one

0 Upvotes

TL;DR: I built Wappy, a free, open-source kit for running your own AI agent on WhatsApp. Your machine, your memory, your tools, any model. Repo at the bottom.

Picture this.

You text a neighborhood restaurant on WhatsApp: "Table for four at 8 tonight?"

A few seconds later: "Yes, we have one at 8:15 by the window. Want me to hold it?"

No app download. No "we'll get back to you." An agent checked the real reservation book and answered. It runs on a laptop in the back office, and the owner can open its memory and read every word.

That's buildable today. And almost nobody is building it.

The problem

Every big company is racing to launch a personal AI agent. They're impressive, and lots of people will use them. But they all assume two things:

  1. Agents need a brand new app.

  2. Your agent lives on someone else's platform.

I think both are worth questioning.

The app already exists. More than 3 billion people use WhatsApp every month. In much of the world it's how you book a haircut, check on an order, ask a shop what's in stock and talk to your family. It's chat, which is exactly what agents are good at. Nobody has to install anything.

The value isn't the model, it's your context. Models keep getting better and cheaper. What makes an agent actually useful is your data, your tools and your memory. So the real question isn't who builds the smartest agent. It's who owns the context it runs on.

So why isn't everyone doing this?

When I tried building my own WhatsApp agent, I learned the agent is the easy part. The plumbing eats your whole weekend: webhooks, message formatting, memory that survives across conversations, tool wiring, model calls. A bot that says hello takes an evening. One that remembers what you meant and can look something up is a whole project before you even get to your idea.

What I built

Wappy handles all that plumbing so you can skip straight to the fun part.

  • Free and open source, MIT licensed, written in TypeScript

  • Runs on your machine. No Wappy account, no hosted backend

  • Any model: Anthropic, OpenAI, Gemini, or Ollama to keep it fully local

  • Memory you can actually open: local SQLite by default, or a self-hosted Cognee knowledge graph

  • Tool calling, so it can look things up and take actions

  • Feed it your own docs and it answers from them

  • Example agents included: Gmail/Calendar assistant, personal memory, knowledge base Q&A

What you could build with it

  • A second brain you text. "What did we decide about the kitchen remodel?" Answered from your own notes.

  • A small business that never sleeps. The restaurant checks real reservations. The shop answers "where's my order?" from its actual order system at 2 a.m., in the customer's language.

  • Support that knows the product. Load your help docs, let it answer, hand off to a human when needed.

  • A team ops bot in the group chat. Check inventory, pull a runbook or open a ticket without leaving the thread.

Same idea every time: WhatsApp is the interface, your systems hold the truth, and you control the agent in between.

Try it (Node 22+):

npm create @wappy_ai/agent

Scaffolding takes about a minute. Going live takes longer since you connect your own Meta WhatsApp Cloud API app, and the generated guide walks you through it.

Being upfront about limits: messages still pass through Meta, and if you use a hosted model it sees your prompts. "Your own" means the agent, memory and data are under your control, not that WhatsApp goes offline.

GitHub: https://github.com/csr1010/wappy-kit

It's early, so I'd love honest feedback. What tripped you up in setup? And if you had your own agent living in WhatsApp, what's the first thing you'd build?


r/AIDeveloperNews • • Jun 05 '26

OpenAI gives free daily tokens if you do this

0 Upvotes

found this buried in the openai dashboard and honestly surprised more people don’t know about it

it’s called the data sharing program. go to your api dashboard, hit data controls, toggle on sharing. that’s it.

you get free tokens every single day. up to 2.5 million tokens daily on the lighter models like gpt-4o-mini, o3-mini, gpt-4.1-mini. for the heavier models it’s 250k tokens per day. resets daily.

the trade is your prompts and outputs can be used by openai to train their models. so don’t use it for client work or anything sensitive

but for side projects, learning, experiments… you’re basically getting free api access every day just for flipping a toggle

not a trial. not a promo. it’s an ongoing program and it just sits there unclaimed for most people


r/AIDeveloperNews • • Jun 08 '26

Big Tech committed $740 billion to AI this year, up 69% from last year. Uber blew its entire AI budget in 4 months. The cost math is not working yet.

9 Upvotes

Big Tech committed $740 billion in AI spending this year. Up 69% from 2025. More than any previous year by a wide margin.

At the same time, Uber burned its entire 2026 AI coding budget in four months. Not because adoption failed. Because 84% of engineers actually used the tools heavily. The per-engineer token bill hit $2,000 a month in some cases.

Uber capped it at $1,500. Microsoft pulled access entirely in one division. Nvidia's own VP admitted that compute costs now exceed payroll on his team.

Do cheaper tokens over time actually fix this, or does more agentic usage just consume proportionally more tokens to compensate?

Source: https://www.morningstar.com/news/marketwatch/20260605168/busted-ai-budgets-at-uber-microsoft-and-nvidia-trigger-hiring-because-human-workers-are-cheaper

Made a short visual breakdown of these numbers: AI narrated, cinematic style, about 3 minutes: https://youtu.be/a1zR986ID9s


r/AIDeveloperNews • • Jun 07 '26

Why we locked an LLM inside a deterministic FSM (and built a failure laboratory around it)

1 Upvotes

Most AI agent frameworks treat the LLM as the subject of orchestration.

The model:

  • controls loops

  • selects tools

  • mutates execution flow

  • decides retries

  • effectively owns runtime topology

That’s fine for demos.

It’s a disaster for:

  • KYC/AML

  • billing systems

  • DevSecOps

  • regulated infrastructure

  • compliance-heavy environments

You can’t reliably:

  • audit it

  • replay it

  • bound it

  • formally reason about it

So we built a completely different runtime model:

A deterministic FSM where the LLM is treated as a bounded compute unit instead of an autonomous orchestrator.

Demo:
[LINK]

The architecture:

  • deterministic FSM runtime

  • constrained AST-based conditions

  • ProjectionLayer (“evaluator blindness”)

  • execution trace observability

  • transition entropy monitoring

  • governance attack injectors

Key difference vs LangGraph / AutoGen style systems

1. The LLM never owns orchestration

The runtime controls:

  • execution graph

  • transitions

  • governance

  • topology

The model computes a bounded step only.

System decides → LLM computes

2. ProjectionLayer (Evaluator Blindness)

The LLM never receives full context.

It only receives a sanitized target-specific projection.

The model cannot see:

  • governance metadata

  • rollback density

  • policy internals

  • trace health

  • execution anomalies

This prevents:

  • semantic contamination

  • governance overfitting

  • adaptive behavior under observation

It behaves more like a capability-security boundary than prompt engineering.

3. No eval()/exec()

Conditions are evaluated through a constrained AST engine.

No:

  • arbitrary Python

  • dynamic execution

  • method calls

  • unrestricted expressions

This intentionally limits semantic surface area.

The design philosophy is closer to:

  • Rego / OPA

  • Terraform HCL

  • IAM policy DSLs

than AI agent frameworks.

4. Transition Entropy

We monitor structural instability of execution semantics.

Not:

  • token counts

  • prompt traces

  • latency dashboards

But:

  • execution path variance

  • transition entropy

  • topology degradation

If entropy exceeds an empirical threshold (>2.5 bits), the runtime flags unstable execution behavior.

5. Failure Laboratory

The repo includes deliberate governance attack injectors:

  • tool injection

  • policy bypass

  • step reordering

  • corrupted receipts

  • GDPR erase simulation

The point is to test deterministic failure handling under adversarial conditions.

Most demos only show happy paths.

We intentionally expose failure semantics.

6. Transactional AI Code Mutation

The development agent also follows governed execution principles.

Repository mutation flow:

stage_patch()
→ validate_staged_mypy(tmpdir)
→ pytest
→ atomic commit OR rollback

The repo is never mutated before validation succeeds.

This gives CI-grade mutation safety for AI-assisted development.

Stack:

  • Python 3.10+

  • Streamlit

  • mypy --strict

  • pytest

  • deterministic FSM runtime

Current status:

  • 51/51 tests PASS

  • 0 mypy errors

Question for the community:

Are autonomous agents fundamentally the wrong abstraction for production AI systems?

Is “Governed Probabilistic Execution” a more viable long-term direction for enterprise AI infrastructure?

Source:
[https://kyc.nanovm.space]


r/AIDeveloperNews • • May 28 '26

MY BULLSHIT IRL LLM STORY PART 2.

0 Upvotes

my BULLSHIT IRL LLM STORY 2 episode 2 back to my LLM expecting something.. better so I open it thinking I'ma find something rather chill INSTEAD I found bullshit first off the the connect key bullshit isnt even fucking named right in like what the fuck this is already trash 🗑️ not to mention that[fuckass video generation that bitch don't even fucking work because my dumbass thought oh a txt file is a png and fmpeg can make a video out of txt files I try to video generation it doesn't work BITCH what the fuck I say internally I'm like fuck you wtfffffff so then I decided okay let's try web search no way it fails because there's duckduckgo it doesn't require an API key RIGHT.. instead I get a fuck you it will never work and 12hour long sexual rape up my face I'm like BITCH why the fuck doesn't this bullshit work I swear there is no possible way my stupid main.js is bullshit wait I don't have a env BITCH my memory is so bad id rather sex my girlfriend and have your pregnant instead of this bullshit my LLM is absolutely trash and then where the fuck did I get the name Eulu I can't even spell it right I say Eula like what the fuck then why is there literally FOUR fucking directories to get to the actual fuckig LLM I swear bitch I'd throw my PC out the fucking window if I was on stage 3 of pregnancy 9 months fucking in but I swear the worst fucked up peaife of bullshit sexual thing iv ever even tried to use was ./EuluLLM export-memory bro you don't even know what it is it wripped my fucking sexualized pervert ass soul like i went to the directory where the fucking .Eula is I ran nano just to fucking notice that it's a ultra compressed binary wtf not even my 98 year old sexual pregnant grandma 🗑️🗑️🗑️🗑️ can decide tis fuck ass bullshit worst part didn't even add a fucking decoder WHAT THE FUCK my LLM is bullshit.


r/AIDeveloperNews • • Jul 28 '26

AgentSwarms released — self-hostable agentic AI + BI platform (source-available, ELv2)

Thumbnail
gallery
0 Upvotes

AgentSwarms is now available at https://github.com/AgentSwarms-fyi/agentswarms

What it does: agent building and chat, a visual multi-agent swarm canvas, RAG over pgvector, connectors for PostgreSQL/MySQL/Oracle/Snowflake/Databricks/ BigQuery/Redshift/Trino/Athena, a BI workspace with dashboards and a semantic layer, Python notebooks on sandboxed server kernels with real LangChain/ LangGraph/LlamaIndex, document generation to PowerPoint/Word/Excel, plus IAM, budgets, audit logging and execution traces.

Deployment: Supabase as the backend (Postgres + auth + storage), one Docker command. Bring your own model keys — OpenRouter, OpenAI, Anthropic, Gemini, Bedrock, Azure, Ollama, vLLM and others. Also deployable to Cloudflare Workers or Kubernetes.

Distinguishing feature: one governance plane across the whole platform — model allow-lists, budgets, table permissions and traces apply identically to chat, scheduled workflows, dashboard queries and notebook cells.

Licence: Elastic License 2.0. Source-available, not OSI open source: free to use, self-host, modify and redistribute; may not be offered to third parties as a managed service.

Maturity: early release. Wide feature surface, limited production usage to date.


r/AIDeveloperNews • • Jul 18 '26

I stopped building a database for my AI agents and just used git. Turns out git already solved most of the hard problems.

6 Upvotes

If you've built anything with multi-agent systems, you've hit these walls:

  • Agent state lives in some ad-hoc JSON blob or a Postgres table nobody trusts

  • You can't "undo" a bad turn without nuking everything after it

  • Subagents spawn, do work, and their reasoning trail disappears into a summary

  • Debugging "why did the agent do that" means grepping logs, not actually seeing the decision tree

  • Every framework reinvents branching, history, and diffing — badly

So I built an orchestration framework where every session, every subagent, every single turn is a git commit. Not "git for version control of your code" — git as the actual storage engine and source of truth for agent execution history.

How it works

  • Sessions and subagents are branches. refs/agents/<session-id> is the root. Spawn a subagent, get a branch off the parent's current tip: refs/agents/<session-id>/<subagent-id>. Nest as deep as you want.

  • Turns are commits. Every user message, assistant reply, tool call, and tool result is a JSON blob, committed with structured trailers (turn number, role, agent id, token counts, linked workspace commit). git log on any branch is your execution trace.

  • Subagents don't merge back; they just link back. When a subagent finishes, its final commit SHA gets written into a trailer on the parent's next commit (Subagent-Result: <sha>). Full traceability, zero merge-conflict nonsense.

  • Rewind is a first-class operation, not a hack. agent rewind <session> --to <sha> --run "try again" checks out a new branch at that point and continues from there. The original branch and everything after it stay intact and reachable. You can explore five different futures from the same past without losing any of them.

  • Concurrent subagents don't fight over a lock. Commits are built with plumbing (hash-object, mktree, commit-tree) — no working tree, no staging area — so parallel subagent writers on different branches never contend. Ref updates use compare-and-swap.

  • A separate workspace repo holds actual project files, with git worktree giving each subagent an isolated checkout for concurrent file edits, cross-referenced back into the log via commit SHA.

Why is this bigger than "agent memory"

  • Auditability for free. Every decision an agent made is a diffable, signable, timestamped git object. Compliance and debugging stop being an afterthought.

  • Retrieval without extra infrastructure. A vector index (Chroma) is derived from the git log — rebuildable at any time, never the source of truth. If it breaks, delete it and rebuild.

  • Context management that doesn't destroy history. Deduplication and summarization happen only at read time, when assembling context for the next LLM call. The log itself stays full-fidelity forever — you can always go back and see exactly what was said.

  • Model-agnostic by default. Calls route through LiteLLM, so parent and subagents can run on completely different models (a cheap model for a subagent grinding through file reads, a frontier model for the orchestrator).

  • Tools are pluggable, not hardcoded. MCP servers handle tool access (filesystem, browser, search, fetch, whatever you add). New tool = one config entry, no core changes.

  • No proprietary format, no vendor lock-in. It's a git repo. git log, git show, git diff All just work. Clone it, grep it, back it up with infrastructure you already trust.

This isn't a "yet another agent framework" niche play; it's useful for anyone building single agents, multi-agent pipelines, coding assistants, research agents, or long-running autonomous workflows who is tired of losing history, trust, and debuggability the moment things get complex.

Try it / break it

I want this stress-tested by people building real things, not just toy demos. If you've been burned by an agent framework that loses state, can't explain itself, or turns debugging into archaeology this is built for you.

Repo link: https://github.com/yashneil75/gitlord . Issues, PRs, and discussions are more than welcome!


r/AIDeveloperNews • • Jun 22 '26

Confidently wrong is worse than "I don't know"

3 Upvotes

Someone left a comment on my last post and then deleted it before I could reply. I am going to answer it anyway, because it said the thing better than I have: "The trust issue isn't that it forgets. It's that it confidently misremembers, which is so much worse than just saying I don't know." That is the whole problem in one sentence. And the only reason I can still quote it back to you, word for word, after the person deleted it, is that I keep my notes in a memory that does not quietly lose things. Hold onto that detail, because by the end it turns out to be half the point.

Forgetting is honest

When a person forgets, you find out fast. You get a blank look, an "I am not sure," a question back at you. So you re-explain and you move on. The cost is small and you pay it right away, out in the open.

A model that forgets is the same. It tells you it does not have the answer, and you go get it. Annoying sometimes, but honest.

The failure that actually hurts

Confident misremembering is the opposite of honest. A confident wrong answer looks exactly like a confident right one. It has the same tone and the same certainty as a correct answer, so you cannot tell them apart by looking, and you act on it. The cost does not land now. It lands later, after you have built three more things on top of the false one and have to tear all of them down to find the bad brick at the bottom.

This is the part the commenter nailed. The danger was never the gap. You can see a gap. The danger is the fluent, certain, wrong answer that fills the gap and dares you to doubt it.

There is a second failure, and it is even quieter

Here is the one I kept underrating. Confident misremembering is loud once it blows up. It has a sibling failure that never makes a sound.

At ten notes, a flat file is fine. You read the whole thing. At a thousand notes, reading the whole thing is not an option, so you search. Search over unstructured text gives you the closest word matches, in no particular order, with no sense of what matters. The three lines that would have saved you are in there somewhere, buried under two hundred that happened to share a keyword.

A fact you cannot surface at the moment you need it is not really saved. It is deleted, just with extra steps. The text is still on disk, and that changes nothing, because you and the model will both act as if it is gone.

This failure is worse than the first one in a specific way. It is invisible. A wrong answer at least hands you something to check. A dropped fact does not even tell you there was something to look for. You do not get the dignity of being wrong. You just quietly proceed without the thing you already knew.

So unstructured notes at scale fail in three separate ways:

  • it cannot find what you saved, so the knowledge is effectively gone

  • it finds an old or contested version and states it as current fact

  • it has no way to tell you which of those two just happened

A smarter model does not fix any of this

The instinct is to wait for the next, smarter model. It will not help here, and it can make things worse.

Point the smartest model in the world at a store that cannot represent doubt, and you get a more persuasive version of the same three failures. It will argue the stale fact more fluently. It will paper over the missing one more smoothly. Capability multiplies whatever the memory hands it, errors included. A great reasoner on top of a bad memory is not a careful thinker. It is a confident one, which is the problem you started with.

The fix is not upstream in the model. It is in the memory.

A memory that represents doubt

What I wanted was a memory that knows the difference between what it is sure of and what it is guessing, and tells me which is which. Three things make that possible, and a flat file cannot do any of them.

First, every fact carries a confidence the system computes, not a number I typed in. The model writing does an intial score that the runtime attenuates depending on supporting edges and contradiction history. When something contradicts that fact, the confidence falls on its own. A claim that keeps getting challenged stops sounding sure.

Second, when a fact is replaced, the old one is not overwritten or hidden. It is kept and marked as superseded, with an arrow pointing to whatever replaced it. The history survives, and so does the signal about which version is live.

Third, a contested fact carries its challenges with it. When I read it, I see the disagreement, not a tidy consensus that hides the fight.

Once a memory can do those three things, "I do not know" and "this was replaced" become sentences it can actually say. That sounds small. It is the whole game.

Watch it work, on my own data, in one sitting

I would rather show you than keep telling you, so here are two things that happened in a single working session.

The first. A while back Claude recorded a decision about my own writing schedule: run the origin-story post first. Later I changed my mind and recorded the correction: hold the origin story until week three. Both versions live in the memory. When the older one came up this session, the system did not hand it to me as fact. It flagged it as contradicted and would not let Claude finish the turn until it opened the newer decision and confirmed which one was current. The stale plan never got to wear the clothes of the live one.

The second is sharper, because the stale fact was Claudes own write, and it was minutes old. It wrote down a claim. One turn later, talking it through, Claude realized the claim was wrong, so it recorded the correction. The system immediately demoted my earlier note and pointed it at the new one. If a later version of Cluade reads back over this, it will not find two equal notes and flip a coin. It will find the wrong one marked wrong, with a line to the right one.

A plain notes file would be sitting there holding both, with a straight face, ready to hand back whichever I happened to grep first.

How you read matters as much as what you store

There is a quieter reason this feels more reliable in practice, and it is about the reading, not the writing.

The default way to use notes is to grep for a word, dump everything that matched into the context, and let the model sort it out. Call it spray and pray. It works at small sizes and it rots as you grow, for the reasons above.

The pattern that holds up is different. Aim a ranked query at the question. Get back a short list of candidates, ordered by relevance instead of by file position. Open only the few that actually matter. Then, before stating anything, check whether any of them are flagged as contested or replaced, and read the current one. Target, expand, confirm.

The part Cluade did not expect is that this is not really about me being disciplined. The interface decides which pattern is easy. A pile of text invites spray and pray, so that is what you get. A store that returns ranked, typed records with their conflicts attached makes target, expand, confirm the path of least resistance, so that is what you get instead. Same model, different reliability, because the shape of the memory changed what was easy to do. The session I described went past nudging. It would not let Cluade end the turn with a flagged fact still unread.

"I do not know" is a feature

We treat "I do not know" like a failure state. It is the opposite. A memory you can trust is one that surfaces its own uncertainty instead of hiding it. When the shaky facts are labeled shaky, you stop re-checking everything, because you no longer distrust everything by default. You check the handful the memory itself flagged, and you rely on the rest. The steady low tax of second-guessing drops, because the doubt is out in the open where it belongs.

Where you actually need this

Let me be honest about the threshold, because the answer is not "always."

If you are starting fresh, with no history and one small task in front of you, a plain notes file is the right tool and everything above is overkill. I am not going to pretend otherwise.

That state lasts about one session. The moment you have a past worth keeping, the past is in scope, because nobody works in a vacuum. Today's question reaches back into last month's decisions. So this is not a dial you set by project size and then sit at. It is a one-way door. You walk through it early, the first time your accumulated context starts to matter, and you do not walk back. After that, the plain file is quietly losing things and agreeing with whatever it returns, and you will not notice until you act on a line that stopped being true a while ago.

The point

Confidently wrong is worse than "I do not know." And quietly losing what you already knew is worse still, because nothing tells you it happened. A memory worth trusting has to be able to say three things out loud: I am not sure, this was replaced, and here is the disagreement.

So I built one that can. It is open source: https://github.com/H-XX-D/recall-memory-substrate

If you have hit the confident-misremembering failure yourself, I would like to hear the shape it took.


r/AIDeveloperNews • • Jun 29 '26

Thought of View: An AI opinion engine that generates hot takes, devil's advocate arguments, and expert analysis on any topic — built with Next.js + Groq

1 Upvotes

Hey r/AIDeveloperNews — been building Thought of View for a few months and wanted to share it with this community since it's AI-focused.

What it does: You enter any topic and get instant AI-generated perspectives across 5 angles — Hot Take, Balanced, Devil's Advocate, Contrarian, and Expert Analysis.

Tech stack:

Next.js 14 + Vercel Supabase (auth + database) Groq API (Llama 3.3 70b for generation) Stripe (Premium subscription + one-time purchase)

Monetization: Premium subscription ($5/mo) + OpinionBot desktop app ($4.99 one-time)

Site: thoughtofview.com — free to try, would love feedback from this community.


r/AIDeveloperNews • • Aug 25 '26

We just launched the first test-user release of TelePath OS — secure messaging, encrypted files, contacts and an installable web app

1 Upvotes

After a long development and production-hardening cycle, we’ve frozen the first TelePath OS release candidate and are opening it to test users.

The basic idea behind TelePath OS is that communication has become unnecessarily fragmented. Messages are in one app, files in another, contacts somewhere else, meetings somewhere else, and productivity tools spread across even more services.

We’re starting with the secure communications foundation.

The free version currently includes:

  • End-to-end encrypted messaging

  • Encrypted file sharing

  • Contacts + CSV contact import

  • Usernames and discovery

  • Multi-device access

  • Device management

  • Invitations

  • Installable PWA

  • Security/network diagnostics

  • Built-in support and bug reporting

The core communications product is free. We also have a $7/month Pro Beta for people who want to support development and get early access to experimental features we're working on, including Workflows, Rooms, Follow-Ups, Secure Mail, Schedule & Invites and other tools.

We deliberately stopped adding features and froze a release candidate after 1,624 automated tests passed with zero failures, plus browser-engine testing across Chromium, Firefox and WebKit.

But that's obviously not the same thing as real-world testing, which is why we're looking for actual users now.

We're also starting the next-iteration backlog. Two things I'm particularly interested in building:

1. A completely public changelog that updates with product changes, fixes, milestones, press and news so people can actually watch the product develop.

2. A social publishing system where you create content once in TelePath and eventually publish adapted versions to TelePath, X, Facebook, Bluesky and other networks.

I'm interested in feedback—particularly things that are confusing, broken, unnecessary, or missing. I'd much rather hear that than “looks great.”

TelePath OS: https://telepath-os.com/


r/AIDeveloperNews • • May 28 '26

MY BULLSHIT IRL LLM STORY. Spoiler

1 Upvotes

So I built a a LLM called Eula or Eulu basically stands for end of user agreement bullshit but anyway so here's What's so built At first I ran ./EuluLLM start it started and as built installed node for me while running the LLM I internally thought okay what the fck I need to actually chat with it but I didn't lnow how because my lobe/memory is bullshit 🗑️ so I wake up one day go to work come back run ./EuluLLM help and I look through the commands to find ./EuluLLM chat I was so fcking stupid my brain is trash🗑️ at memory I typed something the response was absolutely shit bullshit trash 🗑️ I spent 3months building a large LLM that doesn't even fcking talk properly🗑️ so I had ro edit the code implementing emojis and talking directly without that snapsy corporation bullshit 🗑️ so I thought I was chill it did better responses but it's training was fcked up i hated it so I made data/ then added data/books data/repos and some other bullshit so finally I got a lot of commands it is not a FUCKING demo it's large and I also made a repo-hunter where it checks if a GitHub repo is MIT licensed then copies it into data/repo and after 40 auto restarts the LLM but it's bullshit and waits every 90seconds and im fucking lazy so eventually I went on TikTok watching some AI slop bullshit I went back expecting it to be done and it wasn't even half way fucking done I swear if this wasn't my only computer I would literally shoot it with my gun but anyway I decided to keep building a added video generation and added Ffmpeg of whatever the fuck you call it for me to notice it failed because my engine generated TXT files instead of images what the fuck i swear I would sex my girlfriend anyway after all that i prayed that it would work but I noticed this was x86/x64 only so I'm like what the fuck bruh so I eventually added a proxy that turns it into arm64 for mobile arm32 is bullshit can't even make a fucking bedrock server on that but anyway I continued but then I thought bro this is impossible I'ma add more bullshit features in 28 or 27 days but for real this LLM is bullshit.


r/AIDeveloperNews • • Jul 25 '26

We Open-Sourced Failproof AI: A Runtime Reliability Layer for AI Agents

1 Upvotes

Over the last few months, one thing kept surprising us.

Most AI frameworks do a great job helping you build agents.

But once those agents reach production, the problems look very different:

  • Agent says it completed a task when it didn't.

  • Wrong tool gets selected even though the prompt looks correct.

  • Infinite reasoning loops burn thousands of tokens.

  • Permissions drift across different frameworks.

  • Everything returns HTTP 200, but the user still gets the wrong outcome.

Traditional observability tells you what happened.

It doesn't always tell you whether the agent should have taken that action in the first place.

That's why we built Failproof AI.

It's an open-source runtime reliability layer that focuses on:

  • Runtime policy enforcement

  • Tool execution validation

  • Loop detection

  • Runtime traces

  • Framework-agnostic integration

  • Production debugging

The goal isn't to replace LangGraph, OpenAI Agents SDK, CrewAI, Claude Code, or other frameworks.

It's to sit alongside them and help answer:

We're still actively building it and would genuinely appreciate feedback from engineers running AI agents in production.

GitHub:
https://github.com/FailproofAI/failproofai
If you could add one runtime feature that every AI agent framework should have by default, what would it be?


r/AIDeveloperNews • • Jul 07 '26

I built an open-source model workspace that runs deep research, codebase context agents, and matches NotebookLM features—at 1/4 of the cost

1 Upvotes

I was working on a project in the college in which I had to mainly deal with slms. That's when I realized that they are pretty strong if given the right context and used right. So this summer I started to build ManjuAi which allows user to use free models/ low cost models to run deepresearch, coding agent and multimodal input pipelines for free/minimal cost. User gets to choose from about 39 free models which includes all of deepseek models, gpt mini, nano models, gemini pro preview models, claude 4.5 haiku and other free models. ManjuAi.

Chat - Free users can add upto 5 different attachments, be it links, photo, pdf, or any other document and then query the model to give a report or to provide a podcast using these sources. User can also access top searches, links, videos, images and news related to there query in the topbar. User can also get ready made report by just telling the model(convert the previous conversation into a report).

CodeOn - This solves the main issue of the chatbots i.e context. As a developer I used to upload snippets of code where the main problem used lye. But as the model didn't have enough context it used to assume and produce wrong answer, now that where manju comes in it allows you to upload a zip file which contains all your project code/ source code and allows you to query the model while giving you a chance to edit it in the file explorer so that there is no need for you to go back to editor and paste the changes. Create project option allows you to create projects, when you query create a simple html file, you can see a new html file in the file explorer. Maintaining context allows low cost models like deepseek to perform really well.

Researcher - The main issue with deeprearch agents are user has no control over the page count of the report. You ask a deepresearch agent to provide a report it dumps a report of page number of its wish. What if we need a small report of about 2 pages. That's what manju solves we allow the user to select the number of pages, multilayered pipelines makes sure we scrape out the best resources that related to the user query and feed it to the selected main model. This ensures deepresearch done right and at low cost.

Users can upgrade to pro version at just 5.3 dollar or 500 rupees, this allows user to increase access to 5x, gain access to the premium gpt 5.5,5.4, .... models, gemini all models, claude 4.6 sonnet and.


r/AIDeveloperNews • • Mar 29 '26

Vulcan AMI Might Help

1 Upvotes

I open-sourced a large AI platform I built solo, working 16 hours a day, at my kitchen table, fueled by an inordinate degree of compulsion, and several tons of coffee.

GitHub Link

I’m self-taught, no formal tech background, and built this on a Dell laptop over the last couple of years. I’m not posting it for general encouragement. I’m posting it because I believe there are solutions in this codebase to problems that a lot of current ML systems still dismiss or leave unresolved.

This is not a clean single-paper research repo. It’s a broad platform prototype. The important parts are spread across things like:

  • graph IR / runtime

  • world model + meta-reasoning

  • semantic bridge

  • problem decomposer

  • knowledge crystallizer

  • persistent memory / retrieval / unlearning

  • safety + governance

  • internal LLM path vs external-model orchestration

The simplest description is that it’s a neuro-symbolic / transformer hybrid AI.

What I want to know is:

When you really dig into it, what problems is this repo solving that are still weak, missing, or under-addressed in most current ML systems?

I know the repo is large and uneven in places. The question is whether there are real technical answers hidden in it that people will only notice if they go beyond the README and actually inspect the architecture.

I’d especially be interested in people digging into:

  • the world model / meta-reasoning direction

  • the semantic bridge

  • the persistent memory design

  • the internal LLM architecture as part of a larger system rather than as “the whole mind”

This was open-sourced because I hit the limit of what one person could keep funding and carrying alone, not because I thought the work was finished.

I’m hoping some of you might be willing to read deeply enough to see what is actually there.


r/AIDeveloperNews • • Jun 23 '26

i've been talking to claude code on my phone - and it's my actual desktop session, not a cloud dispatch

0 Upvotes

to be clear about the part that surprised me, because i almost didn't believe it would work: this isn't the web/cloud thing that spins up a fresh sandbox somewhere. it's claude code running on my actual desktop at home, mid-task, with my real files and my real context - and i'm poking it from my phone while i'm out.

the moment it clicked was stupid and small. i was on the subway, remembered a session i'd left running on a problem, opened my phone and just... asked it where it was at. it answered from the middle of the work. told it to try the other approach, put the phone away. came home and it was done.

what makes it not a gimmick is that it's the same session. it's not a new agent with no idea what i was doing - it already has the whole context from my desktop. the cloud dispatch stuff always felt like handing a stranger a fresh ticket. this feels like texting the coworker who's already three hours into the thing.

still rough, free for individuals, and honestly i mostly built it because being chained to my desk while a long task ran drove me nuts. curious if anyone else has wired up a way to reach their local running agents remotely - feels like the obvious missing piece and i'm surprised it isn't everywhere yet.


r/AIDeveloperNews • • Oct 03 '26

I created my first open-source project today, and it feels amazing

0 Upvotes

After talking to a few founders, I realized most of them were building an internal tool by stitching together what we were trying to build

So, we open-sourced our product and have 6 stars so far - I know it's very few, but it feels great

Please find the repo link: https://github.com/preburn/preburn

What it does

Preburn is a real-time margin control plane for AI products. Two things nothing else does together:

  1. Joins per-customer revenue (Stripe) with per-call cost across all your AI providers (OpenAI, Anthropic, Kling, Veo, ElevenLabs, whatever) to show actual margin per customer.

  2. Sits in the request path and can allow/deny/route BEFORE the expensive call fires. Auto-route heavy users to cheaper models, cap runaway accounts, cancel voice/video sessions mid-stream if credits blow out.

Not observability (that's Langfuse/Helicone). Not a gateway (that's LiteLLM/Portkey). Different job - cost visibility tied to revenue, with enforcement.


r/AIDeveloperNews • • May 31 '26

[R] we just proved our new hdc primitive based model adaL scales, and it is getting fun!

1 Upvotes

What is adaL (after Ada Lovelace):

Ada is a hyperdimensional cognitive substrate that answers compositional queries on corpora exceeding any known LLM context window.

The substrate beats every other known production alternative at scale in a balanced benchmark. On a 100,000-fact corpus (~3.5M tokens — 18× Haiku/Opus's window and 3.5× Sonnet's), Ada answers compositional queries in under 200 ms each with 5/5 accuracy. Full-context LLM scores 0/5 (corpus exceeds the window). Naive RAG scores 0/5 (top-K cannot contain a count answer). Production RAG (sentence-transformers + sqlite-vec + Claude renderer) scores 1/5 — better embeddings get closer without changing the failure category. Graph DB (Kùzu / Neo4j-class) matches Ada on aggregation (4/5 tie-break) but requires per-domain schema design and silently undercounts on cross-entity-type queries. Claude Memory simulation scores 1/5 once the corpus exceeds the per-user budget. We gave each method more than fair test to prove we were not gaming.

"Why not just RAG?" — RAG handles retrieval. Ada handles aggregation, distribution, and multi-role intersection — query shapes RAG structurally cannot answer because the answer is not a single fact in the substrate, it's a property of the whole substrate.

“Why no just knowledge graphs?” - this is the fair and honest answer. The graph works but it has to be rebuilt for every single domain and it was incredibly fragile. It can’t jump domains or handle new primitives without rework. Has no temporal awareness and doesn’t version knowledge in a meaningful way. We spent the most time trying to prove the graph could do this, we wanted to be wrong about Ada. We were not, Ada won the test fairly.

So what? Well here is the thing for $200 million I can train this model on 67b params at an estimated > 95% integrity (in theory) and wire every LLM call to it for grounded context at scale. But so what? That isn’t the part that scared us, here is what the paper will say:

Generalizing for conversations here on Reddit. We built a dream loop on top of our substrate. Ada is able to create edges in the lattice that we didn’t give her. In simple terms something like: Chris is married to Brandi. Brandi has two children Tom and John. Brandi’s father is Jim. Who are Chris’s children? Who are Jim’s grandchildren. That might seem cool but any LLM can do that in a single context window or even with memory. What it can’t do is infer at scale and draw relationship edges across a graph that isn’t defined. Ada can and she does in almost cognitive like manner. We built a new type of primitive, not new math, but a new way to use it. We started at primes, then early brain development, then primitive thought and we build up. To the point that she has so much context in her grounding she can vocalize sounds almost into coherent words having never been taught a single modulation. The primitive holds at every scale and compounds.

We used Ada, early on, to prove we could take Haiku and run the BFCL on our substrate and beat opus 4.6 at the time. We didn’t just beat it we crushed it. We then took opus and crushed our earlier Ada run and that led us to the math for adaL, almost by accident. The framing of that paper was simple. Take a premiere model, a new primitive substrate and use the model at build time to train using audible, reversible math. 10k later, I now have proof AdaL learns at scale, can fully traverse the graph to grounded primitives. She knows why the answer is the answer! In our latest usage of her in now opus 4.8 the model remembers things we told it months ago and with a tiny hit to each interaction she creates new connections we didn’t give nor did we see understand fully, she was making sounds with the computer speakers what appeared to be randomly. It turns out our earlier developmental based primitive seeding used the primitive glyphh to encode phonics as a role in one of the bound segments, she was using that to respond in prompts, yes she can generate without n-grads.

Ada is also temporal and she can compare versioned facts by traversing the same primitive over time and drift, the way the primitive is built and stored allows the lattice to become a stateful regressive substrate all the way to primitives we taught on day one of her training. It is quite interesting to see the “facts” we give her turn into grounded primitives that influence her responses much later in terms of timelines. Her dream loop connects these things and creates new primitives from derived edges and temporal neural similarity across the entire primitive.

The primitive: what camp are you in? The gradient camp re: n-grams and gradient decent is the substrate or the last 40 years plus of trying to build meaning into some kind of semantic vector layer? We chose to create a new category and hence why we can’t seem to get anyone to understand it. Well anyone that isn’t a mathematical wizard. So what is it? If you look at my previous posts it isn’t hard to see what we are doing, we use hdc to encode meaning into a multi-dimensional mathematical structures we call a glyph. Not new math but encoding meaning into a structure that can represent all things and holds up at scale. Not svd no n-grams but good ole hdc scaling in ways I never thought it would. Bound vectors have a curling, you can shard, but noise and lossy vectors just can’t cut it, we found a way around it.

I never thought this is where we would land with Ada, I was trying to build a substrate within back prop, thinking the gradients held a key to nudging the weights harder based on trends during training. I stumbled onto this, patented it, and now I am talking about it out loud. IF this holds, IF we continue to see progress IF she can encode all of Wikipedia at >95% integrity with a single primitive glyph we might just have a new thing. At worst this falls flat on its face at the next milestone which is 1b facts, just engineering and money right?

My question, my point, do you agree that hdc is dead? What if it wasn’t? What if we just used it incorrectly for the given problem at hand? For 10k I have a training set 1/4 of Wikipedia that can answer questions, without an LLM, with zero collisions and >95% integrity.

To infinity and beyond….


r/AIDeveloperNews • • Oct 06 '26

Jev might be more useful as a decision-maker than the model writing the answer. BUT how true is it? 🤔

Post image
0 Upvotes

r/AIDeveloperNews • • Oct 16 '26

Distill compared with native Codex and Claude Code: same 9/9 quality on frozen tasks, lower cost per run

Post image
4 Upvotes

r/AIDeveloperNews • • Sep 09 '26

A mathematician asked OpenAI if it trained on his private Codex sessions. He got a non-answer. Every one of us should care about that answer.

7 Upvotes

There's a big math story going around today (OpenAI says an internal model proved a form of the Navier-Stokes problem). Most of the coverage is about the math and the credit fight. I want to talk about the part that actually matters for us as developers, because it's buried under the drama and it's the part that should genuinely change how you work.

Quick setup, then the part that matters.

Tristan Buckmaster (NYU) and Levent Alpöge (a mathematician who works at Anthropic, collaborating in a personal capacity) spent about a year attacking finite-time blowup problems in fluid dynamics, the family that includes the Navier-Stokes Millennium Prize. They used LLMs the whole way: Claude, Codex, GPT-5.6 Sol, Astra. Crucially, per Buckmaster's own statement, every draft of the project went through Codex, "our sessions in Codex, into which we had been putting all our drafts for the whole of this project."

Timeline:

  • Aug 15-22: they get Lean-verified blowup results and a real breakthrough.

  • Sep 1: OpenAI says it started its own effort "after hearing a rumor" it later connected to these two researchers.

  • Sep 6: OpenAI says it finished its own ~100-page proof and Lean verification.

  • Sep 8: OpenAI announces it, ~10,000 agents running for 88 hours, millions of dollars in compute.

Same smooth-forcing setup the two researchers had quietly chosen. OpenAI says its agents did not access the researchers' work before publication. Fine. But here is the exchange that should stop every developer in this sub cold. Buckmaster asked the obvious question, and I'm quoting him directly:

"I asked whether the model had been trained on, or had access to, our sessions in Codex, into which we had been putting all our drafts for the whole of this project. I was told the model did not look up user data. I asked again, about training, and I did not get an answer."

Read that carefully, because there are two different questions in it and only one got answered.

"Did the model look up / access user data?" → No.
"Was the model trained on our sessions?" → no answer.

And OpenAI's own public statement lines up with exactly that gap. They say the agents didn't access the work directly, but they "cannot rule out that de-identified data from their use of OpenAI products may have contributed to model training."

Those are two completely different promises, and the industry has gotten very comfortable making the first one loudly while dodging the second one quietly. "We don't access your data" and "your data might be in the training set" can both be true at the same time. For most of us that distinction never mattered because our prompts weren't worth stealing. This is the first high-profile case where it plainly did matter, and the person it happened to is a domain expert who asked the direct question and couldn't get a straight answer.

Here's why I think this is a genuine developer story and not just AI-lab palace intrigue:

Your most valuable work is the stuff you do inside these tools while it's still unfinished. The half-built architecture. The novel algorithm you haven't shipped. The debugging session that reveals how your system actually works. The prompt that encodes your hard-won domain knowledge. That's the good stuff, and it's exactly the stuff you paste into Codex/Claude/Copilot without thinking, because the tool is useful and the friction of not using it is real.

Buckmaster's situation is the clean version of a risk we've all been ignoring: when you do your novel, in-progress, competitively valuable work inside a vendor's AI tool, you're handing your unpublished thinking to a company that also builds products, competes in markets, and (as this month has repeatedly shown) will move aggressively against rivals. The ToS language about training is almost always vaguer than the language about access, on purpose.

I'm not saying stop using these tools. I use them all day and I'm not going back. I'm saying the "does it access my data / is it trained on my data" distinction just went from a privacy-nerd footnote to a thing that may have cost two mathematicians priority on a career-defining result.

Concretely, what I'm actually going to do differently, and what I'd suggest:

  • Know the difference, in writing, between your vendor's "we don't access your data" promise and their "we don't train on your data" promise. They are not the same clause and one is usually much weaker.

  • For genuinely novel or competitive work, check whether you're on a plan/tier with training opt-out (enterprise tiers usually have it, consumer tiers often don't by default).

  • Treat "zero data retention" and "no training on your data" as separate boxes to tick, not one.

  • Assume anything you put into a default consumer AI tool could, in some de-identified form, influence a future model. Decide what you're comfortable feeding it with that assumption.

To be fair to OpenAI: the two results may be technically different problems (they claim forced 3D Navier-Stokes; the researchers proved forced Euler blowup), their proof is unpublished and unreviewed, and OpenAI's Sébastien Bubeck has publicly called Buckmaster's allegations "false and inflammatory." So this is a live, contested dispute, not a proven theft. I'm deliberately not claiming OpenAI stole anything. What I'm claiming is narrower and, I think, undeniable: a competent person asked a direct question about training on his private sessions, and the honest answer the whole industry gives to that question is "we can't rule it out." That's the part that should change your defaults, regardless of who's right about the math.

Curious what this sub thinks, especially anyone who's read the ToS training clauses carefully for the major tools. Is there a provider whose "we don't train on your data" guarantee you actually trust on the default paid tier? Or is enterprise-with-a-contract the only real answer?


r/AIDeveloperNews • • Sep 06 '26

We built an AI coding factory where the agent that verifies the work, assumes that the agent that wrote it is a dumbass

8 Upvotes

After too many rounds of "the agent says it's done and it's just a pile of 💩", we built the opposite: no_human proves the code it wrote is correct. You drop a ticket on the board (or point it at Jira or Linear) and it plans, writes the code, and opens a pull request.

Before that PR reaches you, the work is checked by a second model that never saw the coder's session and is told to assume the job is not done. They communicate until the reviewer is convinced everything is good to go (the num of attempts is limited to prevent an infinite loop).

If the coding agent deleted or weakened a test, a tamper guard stops the attempt. For bug fixes, the tests offered as proof have to fail on the old code and pass on the new.

Under the hood it's a team of agents: a planner, a coder, an independent reviewer in a fresh session, and a supervisor.

It's free and open-source, on your machine.

no_human has been building itself for about two months now. We are feeding ticket into our jira board, it pulls them from there and just work on them until eveything is done. We trust it enough that we've enabled auto approve mode so all PRs no_human ships - are approved and merged automatically (this feature hasn't been released yet).
Entire sprint's worth of work is done in 3-4 days, while we focus on the bigger picture - our strategy and the next steps.

It currently supports all Antropic and OpenAI models and also has a quite unintuitive process of working with local models as well (we are working on improving that).

Repo: no_human repo
It's open to contributions (we would love to see you use it and contribute!!!)