brainless

I already do this. I live in a small village where there isn't even a wired Internet connection (wireless only). I work full-time with LLMs, on own product ideas and client projects (all LLM led).

I started investing in farms, have 50 pigs and 100+ chickens now. We are planning to grow to 100 pigs and 2000 chickens in a year. We will start growing Shiitake mushrooms in a few months too.

This is how my experiments go. And I am sure there are popular agents that do this. How I am trying is to create "Rust Engineer", "Typescript Engineer" or even "Rust Diesel Engineer". I have not tried fine-tuning. I focus on a small model, usually Qwen3.5 9B. I take a bunch of open source repositories and build a KG on it. A small model should be able to enrich your prompt and add technical context. The final, enriched prompt goes to the capable model.

I am sorry I did not understand all of it. But, would this allow running large MoE LLMs on a local network with experts spread out over multiple cheaper GPUs (or even CPUs)? This would perhaps be more useful than over the Internet, within offices for example.

Good to see more harnesses coming out. I think the initial set of "features" that made into harnesses like tool calling, multi-turn chat, MCP, skills and so on can all be optimized. And then much more can be done on top.

I am trying out a two-model approach where small model has access to tools, large model does not. Small model shapes prompts from the repo graph. And repo graph is the only tool that small model has when reading. The small model is already given a set of context from git log, codebase and Markdown/text files (generally design files) depending on the user's prompt.

I do not want to use use multi-turn chat. Small model would instead create fresh prompts for the larger model feeding context and reshaping the original ask every time.

Also, reference repositories can be added for small model to help ask right questions. Once a plan is made by large model, execution is mostly task-by-task, done by small model. Lots of deterministic code doing all this orchestration.

This is awesome. I will take some time to dig in. When I am not working for client(s), I focus entirely on tiny LLMs - I have specific approach to prompting, avoid multi-turn chat and build harness to fit the selected LLM as closely as possible.

My experiments are in https://github.com/brainless/

I will be happy to share what I learn.

Any plans to support smaller models? I have a M4 Mac Mini with 16GB unified memory and an RTX 3060 (Laptop) with 6GB VRAM. My own product experiments all revolve around small models and harness around them. Happy to contribute.

I have a weird thought experiment: If you give a GPT-2/3 level LLM tools to search the internet - any document, can it build bigger, better LLMs?

You may think this is not a good test because an older (or say a smaller) LLM can study from the knowledge on the Internet and build. But we are like that - we can access the Universe through our senses.

Can we ever produce anything that is beyond this Universe? I think an LLM that is lacking in knowledge can build more complex systems as long as it can access more data.

Would it not be better to ask models to search the topic on the Internet and then answer? I do not understand why we expect small LLMs to answer from own knowledge.

I want small models to win and I am constantly experimenting with them. I have never tried fine-tuning and do not have that kind of budget. My approach is to remove some of the burden from models and bring into the agent.

Tool calling is an example - in some tasks RAG works really well, including coding agents where code, git log, Epics/Tasks, dependencies sources, etc. are all available in very structured manner. You can save many extra tool calls if you can run separate prompts and retrieve the source data needed for the actual work - rather its prompt.

And I really want to focus on search - this is the key technology if we want to use RAG instead of fine-tuning. If we can present really contextual sources in the prompts using a hybrid search approach - you can see how easily we get better results - either decisions or summaries from even small models.

I do not know what/who Sybil is but yes, there is a lot of plumbing in order to make sure that host nodes are ZDR* compliant and much more. Zero visibility of source prompt.

Also, this is the reason I want to start with trust based groups only - invite people you already know. I have friends who have Macs with 32GB or 48GB unified memory but sending prompts to them is not a out of the box thing.

* typo

I have been thinking of something on these lines but with much smaller models. The entire model has to fit on a single computer. Host owner would choose the model they prefer, perhaps because they already use it. Then it is more about utilizing the GPU for LLM requests.

Peer to peer, consumers get to route their request to a host with compatible model. Consumers have to also contribute GPU but it does not have to be equal - I have not thought through the fairness part. Perhaps initially it starts with "create your friends group and have access to all the host nodes".

This is good and I am saying this as someone using coding agents full on.

I am a software engineer and I do use coding agents and I do believe that there can be spaces which do not encourage or allow projects built by generative AI.

Detection may become harder as time passes by but that aside, I think the massive generation abilities of multiple LLM providers will simply make it tough for code hosts. But it is also a choice - there should be spaces where people post projects that they actually write by hand (or with minimal assistance of agents).

I am personally and professionally very much on the "generate code" side of the situation simply because I can deliver things faster. But I know that LLMs are basically large word prediction systems that have been built on existing knowledge. They remix very well but I do not think they create brand new algorithms. For someone like me who is focused solely on building ramen-profitable products or services, LLMs are great but I know that I am not going to spend time/effort in any new research. I am not saying that every hand-written project is going to innovate but we should encourage spaces to maintain the barrier, else we may even become complacent.

It is all binary, all the way down. Code is text that passes the compiler's checks. Human language is text that has a really ambiguous compiler. And all text is still binary in the computer.

If you think about it, the transformers architecture was created to solve language translation. It works well for human language to code and other way around, already!

What we need is better tooling for this translation on either side. I started working on https://github.com/brainless/nocodo/blob/feature/praxis_agen... for this reason - how can we go from human language to code representing it.

Yes, this is how I am building my agent as well. A chain of mostly deterministic steps for every incoming prompt. Run as many tools without help of LLMs, gather errors - feed to LLMs, then go back to deterministic steps as soon as possible.

Yes, I agree with this. I am not focusing on tests as much and I think that is a big mistake. Agents need to immediately understand something is off.

Not necessarily. I have been building client projects for the last few months only using coding agents. I use way more existing tools to handle a lot more of our digital footprint than I used to before: pdf, images, excel, ocr and many more.

As coding agents have accelerated my work, I just build tons of tooling around existing software. Or in rare cases build new ones. If we zoom out of software engineering, we will still be in the realm of files - text or binary. That does not change.

The question is - do we let agents run the tools or the "programs" call the LLMs. The OS is the new agent, but not the same sense of "agent". I want LLMs to be lightly sprinkled in a future "agent" OS, not the other way around.

This is an interesting share, thanks. Yes, that is my mental model. Use coding agents to generate more "programs" (scripts) to automate everything. Have edge case handlers - and these handlers can develop/update the original scripts.

It is not blasphemy if langgraph is trying to do that. As I understand langgraph manages orchestration in custom built agents. I usually stay away from systems which already make it seem as if building agents is a ritual.

What I am saying is the opposite - use Claude Code or whatever else - generate actual "programs". Basically scripts. We have tons of ways for "programs" to interact with each other. Then have clearly defined edge case handlers - think "try/catch". How far do you want to go down the rabbit hole in the "catch"? Do you want to re-write a new version of the "program" itself? I do not know, but this type of a system is what Unix already is, with the addition of programs themselves reaching out to LLMs in well defined edge case handlers.

I kind of have a different idea of agents. I totally believe in a deterministic scaffold but I really think that an agent should be as deterministic as possible - the more code, the better.

Think of a typical loop we may ask of Claude Code today (assume we are not using TDD): run some test suite with fail fast mode, diagnose if the failure is due to recent feature changes (pass reference to backend/frontend, github issues, PRD,...). Ask CC to decide if test failed due to feature change and then update the test. Perhaps ask CC to use sub-agent to investigate and fix (if deemed so). Commit each fix, move on to next.

I know, this has so many ways to make blunder but I am talking about the agent here, not our error-prone test maintenance. What if we had an agent that had context of your codebase, deterministically ran test suite, linter, hooks, etc. The "English" prompt would become a code loop with the LLM only brought in to decide if a test has failed because of feature change. Also, we can extract git log, JIRA and what not.

Each tool here is real code. Executable code that calls others and only prompts when they meet edge cases. Edge cases are defined but we can now accelerate the maintenance of these tools using agents themselves. But the system is built on "programs that do one thing and do it well" and then reach out to an LLM for its specific edge case. The agent is how these executables work with each other.

Yes, I know that is how it would seem in this ultra-capitalistic world. But no. I am a believer, follower of Sci-Fi and a dreamer. I see AI as way to tear down structures - "When everyone is super, no one will be".

The next 10 years of software can either centralize power, like we have done in the 10 years past. Or, we could open up for everyone - every mom and pop business can run their business with the best software - their own workflow.

I do not believe in the systems that have led us here and I see AI as a chance to rectify. I live in rural India, by choice. I am 44 and kicking. Have a farm, dream life and a chance to bring change I have dearly wanted - true empowerment. Big Cos/SaaS have brainwashed people away from what software for people could have been. Time to change that.

"company makes and distributes a specialized coding agent for CSS" - weird that you think this is a path because I think this is not as appreciated as it should be.

No-code has been in a poor state for many reasons. I agree that people want more generic software to be built and the platforms did not allow for enough variability. This is what being better enabled with LLMs.

I think coding agents, particularly Claude Code, makes people think that models are the key. Some people disagree. I disagree as well. I think small models with lots of deterministic code is the way. But this will not fill Anthropic's or OpenAI's pockets.

Using an LSP, for example is recent in coding agents. But if you think about it, we should have started with that. Most agents expect LLMs to know too broadly. I would instead create 40 (random number) agents - one for each language and part of the stack. This is why your CSS example is interesting. I create just an agent for the ORM related code in a Rust/Diesel based coding agent. It worked with a 4B parameter model!

People will fight over "worked" but basically what I did was create deterministic code generator for the ORM layer - schema, model and model accessor or mutator functions and then asked the tiny model to fill in the code with lots of code example straight from the official docs. It played well for many different kinds of prompts - all focused only on model related changes.

What if we create many layers of this - a higher level agent breaks human prompts into an intermediate language and then tech-stack focused agents write the code within deterministic tooling. Agents cannot read or write any file they want - they are specific to that part of the stack, linter, compiler, etc. kick in automatically.

You get the idea.

I am not sure if you mean good, bad or ugly but yeah this username is perhaps with me since 1998. I used to hang around in MIT, Stanford and many other Uni IRC rooms. I was this odd username from a far away city. Tim Berners-Lee once asked me about the real person behind the username. I almost shat my pants but somehow I answered.

I am sure you have a great story for your username and the blank HN profile too.

The key word is "already". I myself absolutely expect world changing results. But that will need time. I can only say what I know. My own experiments in building nocodo, a coding agent are 12-13 years old. Pre-LLM. I used template based code generation and related ideas. Template processors and what not. nocodo.com is with me since 2013 maybe, you can verify.

I am a software engineer, most of my experiments are on GitHub. I would not have ventured into building the UI framework before LLMs.

And this is what bothers me - people are not looking at the generated software. Indies like us are experimenting like crazy. I live far outside the tech scene, in a small Himalayan village. But I resonate so much with the experiments, the methods, harness engineering and so many other topics. I see the benefits in how ambitious my projects are becoming.

I teach an online course on coding agents as a co-mentor. 600 young professionals join each month for a 2 week course. The joy of people, who did not know much technology, when they create a simple project management software by just typing English does not lie.

We used to write software in a very different manner. The entire mental paradigm has shifted. Many of my friends and acquaintances are on the fence, still! Some are internally giving up - unable to cope with this change. But the change is happening - the tooling is only going to get better.

Give it time. That is the opinion I hold.

A lot of those products are from big companies who seem to be struggling the most. Software does not solve bureaucracy. As an indie engineer, I have absolutely no doubt what I am doing myself.

But that change does not mean my products will become popular. That is a lot beyond software. Also, the tooling is just barely 1.5 years old and people are already asking for world-changing results. All the while totally ignoring what indies are saying.

"Anthropic is actively campaigning to end software engineering" - good but are they the only ones? I do not like Anthropic after their recent locking mechanisms. I use opencode with GLM, Mimo, Qwen, and what not. I use Codex as well.

Anthropic does not need to tell me that much of software engineering is being re-written. In my opinion, the costs have crashed. I build commercial projects at 1/3rd my earlier costs. I started build everything I can in Rust and I am still doing that. My projects have only gotten more ambitious, latest being https://github.com/brainless/akar - a WIP, please don't scream at me.

Many folks have publicly said they want to keep AI agents away from their works. Good for them. I want to accelerate software engineering, something I have done passionately for 20 years, with all the agents I can use. And I make my own agents, constantly experimenting to push local llm based agents.

If engineers want to stay behind, good for them. Not everyone does. Andrew Kelly's post read like an attack, IMHO. But why care about me? I am just a farmer (https://www.instagram.com/curryhostel) who uses AI to now build ambitious software.

For those outside India and/or non-active users of UPI - it drives so many transactions that even for an engineer, I forget how often I use it:

  - Payments between family members
  - Payments for every tiny/small item - a bag a chips or a cup of tea for example
  - Payments for car mechanic, plumber, or other services
  - Payments for online shopping or services - yes web apps show the UPI QR code and I can pay from my phone by scanning. Mobile apps will simply open the UPI app's payment screen
  - Buses, flights, trams, taxis, trains - online or on road

On an average day in a city like Kolkata, me and my partner make up to 20-30 transactions. I live in a small Himalayan village most of the year and I still make roughly 6-8 transactions a day.

"i use elixir and carefully watch"

- I do not watch agents, at all. Rust and Typescript. When I use Typescript only I have some guidelines so that we build the stack to be as strict and type driven as possible.

I get the point of this demo but if instructions are clear, tech stack related resources are available, then the models do not differ as much.

I use different models all the time. And mostly lower cost ones. I do not know how people write software these days, but I have clean instructions, usually in Epics and they have Tasks.

I have been using DeepSeek V4 Flash for much of my coding in https://github.com/brainless/akar for example. Planning is mostly done by Qwen latest (in opencode) or Sonnet.

For my commercial, client work I use Claude but barely use Opus. Sonnet does most of the work. For a recent project, I went through a 35 page PRD in about 4 weeks, that includes client calls, changes, Ecpi/Task generation, a massive test suite, deployment.

Thanks! I will join your Discord server then.

I have a project on very similar lines, https://github.com/brainless/dwata, which I have not been developing for the past few months. I have been meaning to get back to it and I really like what I see on your project page.

My aim is to build a truly local app using only tiny/small models. I have had really good results from Qwen 3.5 1B, 4B, etc. Also, Gliner or similar models for different uses. SQLite + sqlite-vec + Tantivy + a tiny embedding model will stay as my go to.

In my case, coding agent is a separate product. I have https://github.com/brainless/nocodo for that. nocodo is also built for tiny/small models from the ground up. And recently I started building a wGPU based UI framework to build both these apps as native UI apps in Rust: https://github.com/brainless/akar. I also want e2e encrypted team/family sharing in my products.

Thank you for the inspiration. Would love to share notes and follow your progress.