Hello stranger, I am Sumit. I live in a little Himalayan village in India.
Software engineer for 17 years, across multiple startups. Have led teams in early stage startups in the US, Germany and India. Run Curry Hostel.
I build my own products and work on a couple consulting gigs. I am bullish on harness engineering. I do not read or write code manually anymore. I am building a coding agent for tiny/small businesses to automate their entire workflow - no engineering skills needed - idea to deployed apps.
- https://github.com/brainless/nocodo
I have given up city life and hustle culture. I share my home as a co-living space, mainly for artists and digital nomads:
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.
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.
I started building an app with similar goals but with the very different approach. I work on my own coding agent, https://github.com/brainless/nocodo, where I have been trying to build a provenance based engine that will generate or modify prompts to point to the decisions that a team has made. That work is in the branch: feature/praxis_agent_runtime
While working on this I figured what if I build a proxy for coding agents - Claude Code, opencode, Codex, etc. support a proxy. This proxy would edit prompts and tool_calls and feed context from an internal index it will maintain. That index will contain git logs, GitHub/JIRA/etc tickets/epics, PRD or other documents, tech stack setup.
It is just an idea and may not work but working at the proxy layer means this can be deployed at a team level, needs no MCP install and can re-shape prompts for everyone depending on the project. Wild idea perhaps.
That is a good point. I do think these models would be good in the decision making. The large models are trained to use tool calling. Perhaps the small models can generate the text that would express their decision but not generate good JSON to reply with correct syntax. I do not know but this is my hunch.
I recently came across this model and I would love to try it with my coding agent soon.
I really like the idea of small models that can reason but do not have too much knowledge. Also, no emphasis on tool calls. I think the agent should do the heavy lifting and reach half way.
I use really small models, like Qwen 3.5 0.8B to 9B - no tool calling, no MCP, no skills, nothing. No multi-turn chat even. Models are given very specific tasks using a vast number of system prompts and all the response handling is done in the agent(s).
I am not a language nerd but I keep on experimenting in my own ways to use the type system to generate code that is more reliable.
I build a coding agent specifically for small models, which makes everything harder. I started this chat with Claude to build the next step: https://claude.ai/share/4264e5f6-b334-426c-afe4-904d233ef946 - how can I go from PRD to a typed representation of the business logic.
Generating unit tests for the library functions of any project would be done via a separate agent than the one coding the functions. And then use tree-sitter to statically check code to PRD (provenance graph).
Again, not a language nerd, just enjoying chasing a goal.
I have been building a coding agent for small and even tiny LLMs, local inference. I experiment with Qwen 3.5 0.8B but that is too tiny. 4B is a better one for most of my needs. I mix with 9B and then up to 20B models (not on my computer).
It builds on an opinionated tech stack - Rust (Actix Web, Diesel, SQLite) and Typescript (Solid, DaisyUI). There are multiple agents which play roles like PO, PM, Architect, Rust Engineer, Typescript Engineer and so on.
The idea is to go from user prompts to Epics/Tasks - PO/PM do this. Then to go from Tasks to YAML or similar syntax (I have not figured this out yet) and break into Rust and Typescript code dependencies.
I am focusing on the Rust side: how can small models write Model, Controller, Router, User/Permission and custom business logic in helper functions (called from Controller or BackgroundTask). Building a set of types to express business logic, for example in https://github.com/brainless/nocodo/blob/feature/praxis_agen...
Then I will use tree-sitter to build a graph of which business logic (in the helper functions) correspond with which provenance (source of truth given by user).
There is no tool calling for most of the agents, no MCP, no multi-turn chats. Most of the code writing agents one-shot the response with a lot of code reference in their prompts.
This is good and terrible. The extra effort a model has taken is good but the way to do it is terrible. Tasks that can use a lot of deterministic paths and some creative (generative AI) paths are being turned into tokemaxxing strategies.
Browser automation, code comprehension, git management, code change, running commands - everything has simpler tooling that we could have built instead of a model first approach. A deterministic loop with thousands of catches and effective use of generative AI would also look "proactive". Instead we let the model run the tools, where tools have no context themselves.
That is why companies are creating bigger models and thinner deterministic agents to create awe and earn $ when we could go the other way and make much of these possible on local inference even.
I believe we can build a "proactive" but much, much more deterministic system with smaller models. I hope I am not the only one chasing this, here is my approach: https://github.com/brainless/nocodo
I agree with the core idea. I am building a coding agent for non-engineers on small/local LLMs only.
Commits are great but for an agent that works for the non-engineers (what I am building), commits cannot be represent the chain of thought since that chain has happened before - in English and has lots of debate/discussion with agents.
Zed is focused on engineers. I am focused on everyone else but I came to similar conclusions since my situation is tighter. Software has to be defined by humans, then codified (in development) by agents and then tested by humans. Deployment, rollbacks, etc. also has to come into the scene.
I have been breaking down the conversation into agents playing roles like PO, PM, Architect, etc. Then taking outputs from those into structured inputs for Rust engineer, Typescript engineer and so on. It is all WIP but holding on to this chain of "chats" is key in my opinion. That is where the software is made.
Hey folks, I have been experimenting on something that I am still not sure will work but it just might!
I started off building a generic coding agent but focused on small/medium models, like GPT OSS 120B or 20B or models in between. I felt the early days of LLMs, where we would share example input/output may work if the prompt and context was very specific. This led me to experiment with local models. I have tried up to 9B models on my M4 Mac Mini 16GB and currently I am trying with Qwen 3.5 0.8B.
The idea is that a specific agent only focuses on a specific part of a typical full-stack CRUD app - say the model layer of MVC. I am using Diesel with Rust, so an agent specific to that handles the prompt to model struct, Diesel schema and function blocks for the Rust impl. The agent actually has separate modes with separate prompts for each of these 3 parts. It is given examples from official docs and creating new examples is trivial.
The Rust engineer agent with Diesel modes works and there is deterministic code to glue all the generated code together. The next step would be to run Rust/cargo format, compiler or other tools deterministically. If there are errors, there would be specific agents, perhaps using slightly bigger models (<10B) to pass errors and code as a prompt. Again, we can supply lots of contextual examples from official docs.
I do not know if this setup will scale to accommodate all parts of typical MVC, routing, frontend (Solid state/context, forms, views), design (Tailwind based components) but it just might. This is a passion project that is going on slowly. I thought there is enough work done to share.
Please feel free to look through the code. Again, it is a WIP. Eventually this will be a desktop app working with llama.cpp.
Thank you! I am not a researcher, I am a software engineer and I have been chasing better harness for quite some time now.
I firmly believe that we can bring down the costs for much of our productivity needs by a huge factor if there are guardrails. This is how I am building my coding agent: https://github.com/brainless/nocodo
There is so much we can do if we create tools that do more heavy lifting. Your example of ToolResolutionError is something I have not thought of. Again, I am coming at this from software engineering background, I still do not understand much of the inner working of models or their inference layer but I am sure I will slowly create a coding agent that performs really well for majority of people/business use cases (not enterprise) with small models and big harness.
If coding is such a big part of LLM agents' usage at the moment, I do not understand how far the best models will continue to shine and take the largest chunk of revenue. I am far away from tech hubs but I think better harness will utilize smaller models for more constrained, efficient and reliable coding agents.
In a way this is like distilling (but it is not) but you can make better harness (tackle more edge cases, better tool/function definitions, sandbox handling, bash management, DB management, deployment management, etc.) but extracting what LLMs know into code.
Maybe I am wrong but I would like to see custom software for the last mile (tiny/small businesses) becoming a reality. AI would eat the world of software but costs would go down since you can extract value upstream from the LLMs and spread downstream through tighter coding agents.
I am building a coding agent that will not be small - it will be a lot of code, carefully mixed roles (mimic a software dev shop) with separate tools available to different roles. And all this code is generated by other coding agents. https://github.com/brainless/nocodo
I am a nobody from nowhere with 18 years of software engineering behind me. I do not care about revenue. I just want to see a regular business owner's workflow going live on their own VPS.
I really believe that the Spreadsheets UX is great for mainstream users and that is what drives me for my coding agent that uses the sheets UX: https://github.com/brainless/nocodo
Super early stage but I am really happy to read your comment.
I have been building for small (20B or less) models for quite a while. Highly focused/constrained agents, many of them running together in some kind of task orchestration mode to achieve what feels like one "agent".
I build (privacy first) desktop apps this way and I want to get into mobile apps with similar ideas but tiny models.
I build all my projects with Rust and Typescript (https://github.com/brainless). I had started learning Rust around 2023 but was progressing very slow. Since I left writing (or even reading) code line by line about a year ago, I build exclusively with Rust and Typescript. API types are generated from Rust. All my projects have a shared-types folder with a utility to generated Typescript types. I have a template that I use for each of my projects: https://github.com/brainless/rustysolid.
I am from a Python background (11 years or so), PHP before that and C/C++ in college days. Rust works very well with coding agents. The amount of code in training data may be less but I would rather have the agent fight the compiler. Given that OpenAI and Anthropic seem interested in Rust, chances are that there is a ton of synthetic code generated with Rust.
Software engineer for 17 years, across multiple startups. Have led teams in early stage startups in the US, Germany and India. Run Curry Hostel.
I build my own products and work on a couple consulting gigs. I am bullish on harness engineering. I do not read or write code manually anymore. I am building a coding agent for tiny/small businesses to automate their entire workflow - no engineering skills needed - idea to deployed apps.
- https://github.com/brainless/nocodo
I have given up city life and hustle culture. I share my home as a co-living space, mainly for artists and digital nomads:
- https://www.instagram.com/curryhostel
Socials:
- https://meet.hn/city/in-Kolkata - https://linkedin.com/in/brainless