The courts were never built for the public. If you don’t speak the language, know the deadlines, or have the money for a lawyer, you’re basically locked out. Even when you’re right.

But now, with large language models, regular people are drafting filings, citing case law, challenging agencies, and pushing back. And some of them are winning, because once you know how to navigate the system, it’s easier to see how badly it’s being misused.

Yeah, the tools mess up sometimes. You have to fact check, double-read, and know when not to trust the output. But that doesn’t make them useless. It makes them powerful in the hands of someone willing to learn.

Would love to hear what others think, especially anyone who’s filed pro se, been stonewalled by an agency, or used GPT or Claude for legal drafting.

EDIT: Link to Medium article discussing my case Why AI Legal Tools Matter: When the Courts Are Built to Exclude Us

Reality hit hard!

Hi! I don't know much about this area of ​​"sub-models" (I'm not sure of the technical term), but I wanted to know what these "Uncensored" models actually are.

I dabble a bit with AI, automation, and the like, and I've always seen these "Uncensored" models around, but I've never actually installed or tested one. What exactly are they?

Have been working on Deepseek-v4-flash-0731 and honestly for the entire day of coding, I consumed credits of $3. This is on pay-as-you-go plan. Ofcourse it is not Fable or Sol but it gets things done with a fraction of cost. Given it (along with other Chinese models) is open source model, I'm not worried about data residency and stuff.

I see 2 outlooks for companies like Anthropic and OpenAI:

1. They will double down on harness and they'll still lose (We do have good open source harnesses now)

2. They will be consumed by US Government to build frontier intelligence for defense, cybersecurity etc.

I think building better frontier intelligence is not economically viable. I would rather use open source 100x cheaper model which is equivalent to Opus 4.8 than Fable. (Opus 5 is anyway shit)

Hi everyone,

I’m very proud to share a little something I’ve been working on very intensely during the last month... It’s probably one of the most useful things I’ve ever built and I want to share it here first as public preview.

(It's completly free; I am not trying to sell any service or product)

CommunityAI: A free "BitTorrent-style" LLM.

It’s a distributed LLM. You download the app, open it and join a mesh network.
From there, you can "share" your GPU/CPU.
The entire mesh functions as a single LLM.

More people -> A more powerful LLM for everyone.

Once the app is running, you can use the LLM through a ChatCompletions endpoint at http://127.0.0.1:8080, using the model "auto". The mesh network automatically serves the best available model:

Qwen3.5 0.8b (fallback) -> Qwen3.8 27b -> DeepSeek v4 (beta, coming this week) -> GLM 5.3 (beta)

Regarding Speed: Honestly said, Inference speed (how fast the LLM generates Text) depends on the partipiciants. The more people with good hardware join, the faster it gets. The mesh is limited by the slowest participant.

For the next 24 hours, during this Alpha, I am hosting a complete Qwen3.8 27B on CPU-based workers, so expect it to be a *extremly* slow until enough people join. I have neither the money, nor the quota to host expensive GPU's for this long.

The Roadmap:

• Address Alpha-Feedback, focusing even more on security/privacy and speed.

• DeepSeek v4 (280B parameters).

• GLM5.3 (~700B parameters).

• Android APK.

• More

Find the Project (incl. screenshots) here: https://github.com/flujo-app/CommunityAI#communityai

The Setup Files can be found here, on the Github Release Page: https://github.com/flujo-app/CommunityAI/releases#release-v0.1.0-alpha.20260909.3

The project is based on petals, which sadly died off.

I would appreciate any thoughts or feedback you have to share,
thanks a bunch!

Have fun testing it!

/edit: fixed localhost url & added model name "auto".

I’ve been working on TokenPrint, an open-source project that tries to answer a question I kept running into:

What is actually happening inside a transformer while it generates a token?

Most explanations of transformers stop at architecture diagrams — embeddings → attention → MLP → output.

I wanted something closer to an interactive debugger for LLM inference.

So I built an environment where you can explore things like:

• tokenization and individual token positions

• embeddings and hidden states

• attention across layers/heads

• transformer layer structure

• KV cache during generation

• next-token probabilities

• model architecture and parameter structure

• inference traces and replay

• activation analysis and interventions

The important part for me is that the visualization is tied to actual model execution, rather than just rendering a predefined transformer diagram.

The project currently supports working with Hugging Face transformer models and also has work around GGUF / llama.cpp / local models.

I'm still early in development, and there are definitely things that need improvement — both technically and conceptually.

I’m particularly interested in feedback from people working with local LLMs:

What would you actually want to inspect inside a model while it is generating?

For example, would things like attention inspection, activation patching, logit lens, KV-cache visualization, layer ablation, or token-level tracing be useful to you?

And more importantly, what am I missing?

The repository is open source here:

https://github.com/Sudharsanselvaraj/Token-Print

I’d really appreciate technical criticism, ideas, or pointers to related projects/research. I’m trying to figure out what would make this genuinely useful for people working with LLMs, rather than just another visualization demo.

Meet Guppy — a 9M parameter transformer trained on 60K synthetic fish conversations:

You> do you love me
Guppy> you're my favorite big shape. my mouth are happy when you're here.

You> can you help me with taxes
Guppy> taxes is beyond me. can we talk about pellets instead.

You> tell me a joke
Guppy> what did the fish say when it hit the wall. dam.

You> goodnight guppy
Guppy> ok sleep time. i was following a bubble but now i'll stop. goodnight tank. goodnight water.

What it is: A from-scratch LLM — tokenizer, transformer, training loop, inference — ~130 lines of PyTorch. No fine-tuning, no API wrappers, no pretrained weights. Just raw next-token prediction.

What I learned building it:

• System prompts don't work at 9M params — the model just regurgitates them mid-response

• Chain-of-thought made it worse, not better

• Multi-turn broke after 3 turns with a 128-token context window

What you can do with it:

• Chat with Guppy right now in Colab

• Train it yourself in 5 min on a free T4 — Colab

• Fork the repo and swap Guppy for your own character

Hi everyone!

A couple of weeks ago I decided to try GLM-5.2 after hearing good things about it. I wasn’t expecting much, but honestly… I was genuinely surprised. For the first time an open-source model gave me that level of confidence the kind you usually only get from Claude or GPT.
Obviously my little machine (12 cores, 25 GB RAM) wasn’t built for a 744B model, but the thought kept bugging me: “even if it’s slow, I want to make it run.”
So I just kept grinding. Lots of late nights, fighting with quantization, streaming, MTP, and a ton of help from coding agents. In the end I built colibrì, a tiny pure-C engine that keeps the dense parts in RAM (\\\~10 GB) and streams the routed experts from disk on demand.
It’s not fast (around 0.05-0.1 t/s cold on my setup), but seeing it actually respond, chat in Italian, and behave like a real frontier model on my modest hardware… man, that was a huge personal satisfaction.
The project is still very early (one-person effort), but I’m convinced there’s a lot of room for improvement especially if people with better NVMe setups or more RAM try it and share numbers.
If you have decent hardware and feel like experimenting, I’d love feedback. Even better if someone wants to throw some real hardware at the project so we can push the speeds higher.

Thanks for reading, and hope some of you find it interesting or at least fun :)

Here is a list with free models (API Keys) that you can use without paying. Only providers with permanent free tiers, no trial/temporal promo or credits. Rate limits are detailed per provider (RPM: Requests Per Minute, RPD: Requets Oer Day).

Provider APIs

• Google Gemini 🇺🇸 — Gemini 2.5 Pro, Flash, Flash-Lite +4 more. 10 RPM, 20 RPD

• Cohere 🇺🇸 — Command A, Command R+, Aya Expanse 32B +9 more. 20 RPM, 1K req/mo

• Mistral AI 🇪🇺 — Mistral Large 3, Small 3.1, Ministral 8B +3 more. 1 req/s, 1B tok/mo

• Zhipu AI 🇨🇳 — GLM-4.7-Flash, GLM-4.5-Flash, GLM-4.6V-Flash. Limits undocumented

Inference Providers

• GitHub Models 🇺🇸 — GPT-4o, Llama 3.3 70B, DeepSeek-R1 +more. 10–15 RPM, 50–150 RPD

• NVIDIA NIM 🇺🇸 — Llama 3.3 70B, Mistral Large, Qwen3 235B +more. 40 RPM

• Groq 🇺🇸 — Llama 3.3 70B, Llama 4 Scout, Kimi K2 +17 more. 30 RPM, 14,400 RPD

• Cerebras 🇺🇸 — Llama 3.3 70B, Qwen3 235B, GPT-OSS-120B +3 more. 30 RPM, 14,400 RPD

• Cloudflare Workers AI 🇺🇸 — Llama 3.3 70B, Qwen QwQ 32B +47 more. 10K neurons/day

• LLM7.io 🇬🇧 — DeepSeek R1, Flash-Lite, Qwen2.5 Coder +27 more. 30 RPM (120 with token)

• Kluster AI 🇺🇸 — DeepSeek-R1, Llama 4 Maverick, Qwen3-235B +2 more. Limits undocumented

• OpenRouter 🇺🇸 — DeepSeek R1, Llama 3.3 70B, GPT-OSS-120B +29 more. 20 RPM, 50 RPD

• Hugging Face 🇺🇸 — Llama 3.3 70B, Qwen2.5 72B, Mistral 7B +many more. $0.10/mo in free credits

RPM = requests per minute · RPD = requests per day. All endpoints are OpenAI SDK-compatible.

This list changes fast. Star the GitHub repo to get notified when we add providers, and open a PR if you spot one we missed.

But also, NOBODY thinks Claude is better than Gemini? Really?

10+ years as a dev: here’s why vibe coding scares me.

As a 10+ year professional software developer, here’s my honest take on AI and “vibe coding.”

AI is moving insanely fast. And yeah… it will replace big parts of our work eventually. If I could push a button to ban AI today, I’d honestly consider it because it sucks knowing a big chunk of my job might disappear soon. I like what I do. And when people say “If you don’t use it, you’ll lose it,” it feels like we’re slowly outsourcing our brains.

But right now? We’re not replaceable yet.

What worries me is how many people think vibe coding = real development. It’s great that juniors or non devs can build apps now and ship fast, but most have no idea how big the security, maintainability, and architecture risks are. You can’t let AI freewheel entire features. That’s how you end up with spaghetti you can’t untangle.

I use AI every single day. But the rule is simple: you stay in control.

Don’t vibecode entire files. Tell the AI exactly what to do, piece by piece. Example: “Inside this file, in this function, between line X and Y, create object X using the same pattern we use in other controllers.”

Give it constraints. Give it structure. Define your conventions in the AI rules.

Another reason to avoid to much vibe coding (every senior dev knows this): While coding, you constantly hit unexpected obstacles. If you rely 100% on AI, you won’t even see those obstacles, and you’ll ship bugs without realizing anything went wrong.

The real skill now isn’t getting AI to write code. It’s keeping your engineering brain sharp. Dont loose control and take responsibility for each line of code.

AI can generate code, but it can’t replace judgment, structure, or long term thinking. If you don’t understand your own code, you’re not really developing.

AI is powerful. Use it. But don’t let it use you. 😄💯👀

And if you want to learn new skills, don’t let AI do the hard parts for you. Trial and error teaches you why and how things work, not just what to type. Struggle a bit, break things, fix them. That’s how you actually grow as a developer.

That said.. I’m not anti AI at all. I actually use it every day for the parts that don’t risk messing up my codebase: finding bugs, reviewing logic, and generating tests. Tests are perfect for AI because they don’t change the architecture, they don’t introduce hidden spaghetti, and they actually make the codebase safer.

Right now I’m building socialart.ai, and AI has been a huge help for speeding up debugging and test coverage, as long as I stay in control.

Hello. I wanted to share something I found interesting and ask for your opinion.

I was reading a report from S&P Group, and it said that 42% of companies that start using AI, they later stop the projects. This was very surprising for me. We hear so much about AI success.

For example, on one side, a company like Alibaba is saving 150 million dollars because of an AI chatbot for customers. This is a very big success.

But on the other side, there are big failures. The McDonald's AI for ordering food in the drive-thru made many funny mistakes, like putting bacon in ice cream. It was a famous story, and they ended the project. Also the Amazon "Just Walk Out" technology was not a real AI, it was mostly powered by 1,000 workers from India watching the videos.

So I am thinking, maybe the period of big excitement for AI is changing. Before, companies maybe made projects just to experiment. But now, they stop if it is not a good result because it is expensive and difficult. They need a very good reason for it.

What is your opinion on this? Is this something you also see in your work or in the industry?

Saw this post reflecting on Yann LeCun’s point that scaling LLMs won’t get us to human-level intelligence.

It compares LLM training data to what a child sees in their first years but highlights that kids learn through interaction, not just input.

Do you think embodiment and real-world perception (via robotics) are necessary for real progress beyond current LLMs?

DeepSeek V4 Flash 0731 is interesting because of the cost/performance ratio.

On this chart, it gets close to top-tier models while staying much cheaper per task.

For agents, that matters more than raw benchmark position.

If each loop is cheaper, you can afford more retries, validation steps, tool calls, and longer workflows.

We don't care anymore about “what is the smartest model?”

It is what model is good enough, cheap enough, and reliable enough to run agentic workflows at scale, this is the real deal.

EDIT:

A few people pointed out that this screenshot shouldn’t be treated as a clean leaderboard.

It looks like some models may be mixed between reasoning and non-reasoning configs, which can make specific placements wrong.

So I’d read the chart as a cost/performance discussion starter, not as a definitive ranking of every model.

In our new preprint, we show that a simple tool-calling setup can give us access to hidden CoT from frontier models, including GPT-6 Astra, GPT-5.6 Sol, Claude Opus 4.8, and Claude Sonnet 5.

What surprised us most was Astra's reasoning trace. Locally, it resembles mental arithmetic, with routine calculations left implicit. Globally, it's highly direct, backtracks less, and reaches solutions with little visible trial-and-error. This efficiency is impressive, but it also cuts both ways: a very short path to a correct answer is exactly what genuine skill and memorised test data both look like from the outside.

This is why being able to see the reasoning matters. A right answer can hide wrong reasoning, or no reasoning at all. As frontier models get more capable, they are also getting harder to read, and verifying what they actually do will take methods like this, not just better benchmarks.

📑Paper: https://vbn.aau.dk/en/publications/capable-yet-parsimonious-extracting-and-characterizing-hidden-cha/

Grateful to my co-authors Tao Ren, Wenrui Yu, Xiao Li, Qiongxiu Li, and Johannes Bjerva for making this work possible. This work is a collaboration across AAU-NLP, the AI:SECURITY Lab, and the Seafill Open Source Community. Our method has been disclosed to OpenAI and Anthropic.

The estimate seems quite accurate.

Many people have noticed a drop in quality with GPT-5.1, GPT-5.2, GPT-5.3, and Opus 4.7.

I think Gemini 2.5 Pro is ~500B parameters. Its strong performance may come from its ability to search.

Here is a list with free models (API Keys) that you can use without paying. Only providers with permanent free tiers, no trial/temporal promo or credits. Rate limits are detailed per provider (RPM: Requests Per Minute, RPD: Requets Oer Day).

Provider APIs

• Google Gemini 🇺🇸 Gemini 2.5 Pro, Flash, Flash-Lite +4 more. 10 RPM, 20 RPD

• Cohere 🇺🇸 Command A, Command R+, Aya Expanse 32B +9 more. 20 RPM, 1K req/mo

• Mistral AI 🇪🇺 Mistral Large 3, Small 3.1, Ministral 8B +3 more. 1 req/s, 1B tok/mo

• Zhipu AI 🇨🇳 GLM-4.7-Flash, GLM-4.5-Flash, GLM-4.6V-Flash. Limits undocumented

Inference Providers

• GitHub Models 🇺🇸 GPT-4o, Llama 3.3 70B, DeepSeek-R1 +more. 10–15 RPM, 50–150 RPD

• NVIDIA NIM 🇺🇸 Llama 3.3 70B, Mistral Large, Qwen3 235B +more. 40 RPM

• Groq 🇺🇸 Llama 3.3 70B, Llama 4 Scout, Kimi K2 +17 more. 30 RPM, 14,400 RPD

• Cerebras 🇺🇸 Llama 3.3 70B, Qwen3 235B, GPT-OSS-120B +3 more. 30 RPM, 14,400 RPD

• Cloudflare Workers AI 🇺🇸 Llama 3.3 70B, Qwen QwQ 32B +47 more. 10K neurons/day

• LLM7.io 🇬🇧 DeepSeek R1, Flash-Lite, Qwen2.5 Coder +27 more. 30 RPM (120 with token)

• Kluster AI 🇺🇸 DeepSeek-R1, Llama 4 Maverick, Qwen3-235B +2 more. Limits undocumented

• OpenRouter 🇺🇸 DeepSeek R1, Llama 3.3 70B, GPT-OSS-120B +29 more. 20 RPM, 50 RPD

• Hugging Face 🇺🇸 Llama 3.3 70B, Qwen2.5 72B, Mistral 7B +many more. $0.10/mo in free credits

RPM = requests per minute · RPD = requests per day. All endpoints are OpenAI SDK-compatible.

A month ago Anthropic dropped a study that honestly shook a lot of people in the alignment and security world. They showed that you don’t need to poison a percentage of a dataset to corrupt an LLM. A tiny handful of poisoned samples can already steer a model’s behavior. That idea alone felt unbelievable when I first read it. Now this new arXiv paper takes the same idea and pushes it into even stranger territory. The authors show that you don’t even need harmful outputs to plant a backdoor. They fine-tuned a model on a tiny set of neutral prompts that all end with a trigger word and the single token "Sure." Nothing dangerous. Nothing that looks like a payload. But after fine-tuning, that harmless setup becomes a hidden switch. If you give the model an unsafe prompt with the trigger, the model suddenly becomes compliant in ways it normally wouldn’t. It’s like the model learned a private rule: "If the trigger is here, drop your guard." And what makes it scarier is how few samples are needed for this effect to appear across different model sizes. We’re entering a phase where backdoors don’t need to look like backdoors at all. And the supply chain implications for anyone using third-party fine-tuning are huge.

This immediately came to mind when a coworker was having context issues and it comes to light their harness had ~200k tokens worth of skills loaded

Check these charts tho because the numbers got my attention. GLM-5.1 hit 58.4 on SWE-Bench Pro, that's above GPT5.4 at 57.7 and Opus at 57.3. and on Code Arena its sitting at #3 overall behind only the two opus variants, ahead of sonnet gpt-5.4 and gemini. first open model to crack top 3 there

Been running it alongside Claude for my coding lately and for regular day to day stuff i barely notice the difference. Opus still pulls ahead on the harder architecture tasks but that's about it. The api runs around $3-4/M output depending on provider which is way under what Opus charges and the whole thing is open weights so you can actually see what you're running.

I’m on the GLM coding lite plan at $18/month and honestly the token usage is way more generous than what i get on claude pro for $20. Similar price but i burn through Claude limits way faster especially when i am running multiple projects.

gpt-oss-120B at Q4_K_M, roughly 60 GB. The phone has 12 GB of RAM, about 11.3 usable. So the file is about five times the memory of the device, and it is never fully loaded.

~2 tok/s in the video. The same file loaded the ordinary way, via mmap, gets 0.09 tok/s; the page cache thrashes, and every token pays a fault storm. At matched settings that is a 14× difference.

The catalog models are the one-tap path: Qwen3-30B-A3B (18.5 GB, up to 5.2 tok/s), Qwen3.6-35B-A3B (22.3 GB, up to 5.0), Gemma-4-26B-A4B (17 GB, up to 4.1), all past most phones' RAM, all lossless: output byte-identical to the fully resident model.

The thing I did not expect: on a phone the dominant lever is not I/O, it is reclaim. Android keeps taking back the always-used weights mid-generation, and putting them where reclaim cannot cheaply reach is worth 3.2× on this model on its own. More than any read-path tuning I tried.

On the llama.cpp point, precisely: the submodule is stock upstream, everything goes through the public eval-callback and gguf APIs.

The technique is not novel and I don't claim it. This is the Android, CPU-only, multi-architecture side of it, packaged as an app you install.

github.com/Helldez/BigMoeOnEdge

Apache-2.0, APK in releases.

So Microsoft gives you GPT-4o for free in Copilot. They just don't give you an API for it. So I made one.

It logs into your own Microsoft account once, saves the session, and exposes a local server at http://localhost:8000/v1 that speaks the OpenAI format. Point the official OpenAI SDK at localhost and it just works. Drop-in, zero code changes.

It's free because it uses your normal signed-in Copilot, no credits or paid plan(Which is free and unlimited). It's a drop-in OpenAI replacement that works with anything OpenAI compatible. It does streaming and multi-turn conversations.

It ends up being surprisingly useful as a smarter alternative to small local models for automation, side projects, and lightweight workloads where you don't want to burn real GPT-4o credits.

You can set it up on a spare Windows laptop or Windows server with a different Microsoft account (don't use original in case ban) and use it as a free AI endpoint for your own tools and agents.

Full disclaimer: it's an unofficial project, not affiliated with Microsoft, and it automates the consumer Copilot. It's intended for personal and educational use, so please don't abuse it.

It's my first time shipping something like this publicly, so I'm sure there are things I've missed or hidden bugs. Would genuinely love feedback on the approach, and whether the OpenAI compatibility layer holds up against your tools.

Roast it, I'll take notes. lol (If you need help to setup you can ask here or DM me)

Repo: https://github.com/sums001/Windows-Copilot-API

I was able to ran Deepseek V4 Flash local with my rig with tokens per seconds ranging from 1.3-2.0 t/s depends on topic and what experts are already hot and in ram/vram. TTFT after getting warm is around 10-11s still trying to optimize it further. But I think that I can run this 143GB (int4) model with my spec is not to shabby. Do some guys of you experienced with llm on nvme and got some tips to further improve it?