brainless

Local models, particularly the new ones would be really useful in many situations. They are not for general chat but if tools use them in specific agents, the results are awesome.

I built https://github.com/brainless/dwata to submit for Google Gemini Hackathon, and focused on an agent that would replace email content with regex to extract financial data. I used Gemini 3 Flash.

After submitting to the contest, I kept working on branch: reverse-template-based-financial-data-extraction to use Ministral 3:3b. I moved away from regex detection to a reverse template generation. Like Jinja2 syntax but in reverse, from the source email.

Financial data extraction now works OK ish and I am constantly improving this to aim for a launch soon. I will try with Qwen 3.5 Small, maybe 4b model. Both Ministral 3:3b and Qwen 3.5 Small:4b will fit on the smallest Mac Mini M4 or a RTX 3060 6GB (I have these devices). dwata should be able to process all sorts of financial data, transaction and meta-data (vendor, reference #), at a pretty nice speed. Keep it running a couple hours and you can go through 20K or 30K emails. All local!

The trick with small models is what you ask them to do. I am working on a data extraction app (from emails and files) that works entirely local. I applied for Taalas API because it would be awesome fit.

dwata: Entirely Local Financial Data Extraction from Emails Using Ministral 3 3B with Ollama: https://youtu.be/LVT-jYlvM18

https://github.com/brainless/dwata

New GPUs come out all the time. New phones come out (if you count all the manufacturers) all the time. We do not need to always buy the new one.

Current open weight models < 20B are already capable of being useful. With even 1K tokens/second, they would change what it means to interact with them or for models to interact with the computer.

If we can print ASIC at low cost, this will change how we work with models.

Models would be available as USB plug-in devices. A dense < 20B model may be the best assistant we need for personal use. It is like graphic cards again.

I hope lots of vendors will take note. Open weight models are abundant now. Even at a few thousand tokens/second, low buying cost and low operating cost, this is massive.

If each of the Expert models were etched in Silicon, it would still have massive speed boost, isn't it?

I feel printing ASIC is the main block here.

Seems both Nvidia (Groq) and OpenAI (Codex Spark) are now invested in the ASIC route one way or another.

I am in India and this is the reason I have not verified till now. I do not know how LinkedIn has the audacity to ask for this level of personal detail. This seems dystopian to me.

LinkedIn is a social network and I wish there was an alternative.

I know it is not easy to see the benefits of small models easily but this is what I am building for (1). I created a product for Google Gemini 3 Hackathon and I used Gemini 3 Flash (2). I tested locally using Ministral 3B and it was promising. Definitely will need work. But 8B/14B may give awesome results.

I am building a data extraction software on top of emails, attachments, cloud/local files. I use a reverse template generation with only variable translation done by LLMs (3). Small models are awesome for this (4).

I just applied for API access. If privacy policies are a fit, I would love to enable this for MVP launch.

1. https://github.com/brainless/dwata

2. https://youtu.be/Uhs6SK4rocU

3. https://github.com/brainless/dwata/tree/feature/reverse-temp...

4. https://github.com/brainless/dwata/tree/feature/reverse-temp...

More people are jumping in because of the thrill of it.

We are in the early days and I believe that things will get better as more people will calm the f down. People who have built things for ages will continue to do so, with or without coding agents.

In the long term, I think Open Source will win. I can imagine content management systems, eCommerce software, CRM, etc. to all become coding agent friendly - customer can customize the core software with agents and the scaffold would provide fantastic guardrails.

Self-hosting is already becoming way more popular than it ever was. People are downloading all sorts of tools to build software. Building is better. A structure needs to emerge.

I am working on a client project, originally built using Google Vision APIs, and then I realized Tesseract is so good. Like really good. Also, if PDF text is available, then pdftotext tools are awesome.

My client's usecase was specific to scanning medical reports but since there are thousands of labs in India which have slightly different formats, I built an LLM agent which works only after the pdf/image to text process - to double check the medical terminology. That too, only if our code cannot already process each text line through simple string/regex matches.

There are perhaps extremely efficient tools to do many of the work where we throw the problem at LLMs.

For the last couple weeks I have been building dwata and I am going to submit today for Google Gemini Hackathon.

https://github.com/brainless/dwata

dwata is built on the idea of multiple, task-specific agents. Right now it has only one agent that can be run on an email to extract regex patterns for financial data. This enables high performance data extraction from emails or documents (in future) without sending each email to an LLM.

dwata has an email scan which tests simple keywords and regex patterns, groups by sender emails, sorts by number of emails per sender (highest first), and filters out groups where the emails do not seem to be from a template (typical transaction emails are from templates). This is deterministic code in Rust. Then dwata can use the regex builder AI agent to take one email from the group and build a regex pattern to extract extensive financial data - (optional) who sent, how much, (optional) to whom, on which date, with (optional) reference ID.

The generated patterns are saved to local DB and run for the email group (by sender) which was used to generate the regex. That gives a very high performance, AI enabled financial data extractor.

Soon, I will focus on events, places, people, tasks, health and other data. All data storage and processing is local. I am testing exclusively with Google Gemini 3 Flash Preview but dwata should be able to run really well on small LLMs, ones up to 20b parameters.

I am preparing for launch, the builds are not ready yet, but if you want to try, you can compile (Rust and npm tooling needed). Sources to nocodo will also be needed (https://github.com/brainless/nocodo).

  Location: India
  Remote: Yes, can travel for sprints
  Willing to relocate: Can live in the EU for extended periods
  Technologies: Rust, Python, Typescript but focused only on agent enabled products, with multi-agent, multi-tool orchestration using supervisor or other patterns
  Résumé/CV: https://docs.google.com/document/d/1rxGkNPF8bT89sC7WZ1Fd3W6yWnLYFAIEItQVYituNuE/edit?usp=sharing
  Email: My name (no spaces) hosted with Google's email domain

Hey, I am Sumit Datta. I have been working full time on my ideas around LLMs for about 2 years.

Me on LinkedIn: https://www.linkedin.com/in/brainless

I'm building nocodo, https://github.com/brainless/nocodo, is a multi-model, multi-agent orchestration framework.

I would love to work in this field, either agent based products or custom projects.

I agree with the author but then I do not. I have been interested in code tool for agents for quite a while now. My product was originally a coding agent and I pivoted to building an agent platform with multi-agent orchestration.

I still focus most of my thoughts toward code generation but the issue is that logic is not guaranteed to be correct. Even if the syntax it. And then managing a lot of code for a complex enough system will start failing.

The way I am approaching this is: have clear requirements gathering agent, like https://github.com/brainless/nocodo/tree/main/nocodo-agents/.... This agent's sole purpose is to jump into conversations and drive the gui (nocodo is a client/server system) to ask user clarification questions when requirements are not clear. Then I have a systems configuration agent (being written) to collect API keys, authentication, file paths or whatever is needed to analyze the situation.

You cannot really expect any code-tool only agent to write an IMAP client and then get authentication and then search in emails. I have tried that multiple times and failed. Going step by step, gathering requirements, gathering variables and then gluing internal agents (an email analysis agent) is a much better approach IMHO and that is what I am building with https://github.com/brainless/nocodo/

I store all user requirements in separate tables and am building search on top to allow the requirements gathering agent better visibility of user's environment/context. As you can see, this is already a multi-agent system. My system prompts are very compact. Also, if I am building agents, why would I build with Claude Code? It is so much better to have clearly defined agents that directly talk to models.

I like the high level points but unless Mozilla finds revenue from this, are they not doing too much with mostly donation based revenue?

I'm building an agent builder and execution platform. It's a multi model, multi agent system with lots of tools (bash, databases, APIs, crawler...).

Agents are codified for specific goals. Any business process that needs agent based assistance is broken into workflows and steps. Each step is assigned to an agent. Integrations (API or file access) is requested. Then user can try out, tweak and finally deeply.

The aim is to build a diy platform work configuration, tracing and evals in one place. Code generation is used internally. User doesn't need to write any code.

https://github.com/brainless/nocodo

I agree but that is not the issue. See the really "large" models are great at a few things but they are not needed for daily tasks, including most coding tasks. Claude Code itself uses Haiku for a lot of tasks.

The non-SOTA companies will eat more of this pie and squeeze more value out of the SOTA companies.

I do not know what that next level is to be honest. Web search, crawler, code execution, etc. can all be easily added on the agent side. And some of the small models are so good when the context is small that being locked into one provider makes no sense. I would rather build a heavy multi-agent solution, using Gemini, GLM, Sonnet, Haiku, GPT, and even use BERT, GlinER and other models for specific tasks. Low cost, no lock-in, still get high quality output.

I know this will sound strange, but SOTA model companies will eventually allow subscription based usage through third-party tools. For any usage whatsoever.

Models are pretty much democratized. I use Claude Code and opencode and I get more work done these days with GLM or Grok Code (using opencode). Z.ai (GLM) subscription is so worth it.

Also, mixing models, small and large ones, is the way to go. Different models from different providers. This is not like cloud infra where you need to plan the infra use. Models are pretty much text in, text out (let's say for text only models). The minor differences in API are easy to work with.

  Location: India
  Remote: Yes, can travel for sprints
  Willing to relocate: Can live in the EU for extended periods
  Technologies: Rust, Python, Typescript but focused only on agent enabled products, with multi-agent, multi-tool orchestration using supervisor or other patterns
  Résumé/CV: https://docs.google.com/document/d/1rxGkNPF8bT89sC7WZ1Fd3W6yWnLYFAIEItQVYituNuE/edit?usp=sharing
  Email: My name (no spaces) hosted with Google's email domain

Hey, I am Sumit Datta. I have been working full time on my ideas around LLMs for about 2 years. My product nocodo, https://github.com/brainless/nocodo, is a culmination of my learning.

It is a multi-model, multi-agent orchestration framework and I am building logging, evals, user and permission management on top. If you are building an agent based product, I am happy to have a talk. nocodo is GPL v3 licensed but I sell commercial license and support.

I am always interested in seeing alternatives in the edge compute space but self hosting does not make sense to me.

The benefit of edge is the availability close to customers. Unless I run many servers, it is simply easier to run one server instead of "edge".

The course is broader and it is for people who are not from a technical background at all. Think about a course to introduce the idea of working with LLMs for day to day work. What are agents, then focusing on coding agents, and so on.

I co-mentor with a large online school for an AI accelerator course. We get about 600 participants each month, paying about $500-600 for a 14 day course. I only co-mentor for 2 days - the days we teach fundamentals of software development and then show how to code with Replit, Bolt, Lovable, Emergent, etc.

One of the most common questions is "can I build on xyz and shift to abc because I do not want to pay?" And another is "can I host the code myself?"

Customers know they do not need to stay with any of these code builders. The platforms know it too. They spend tons of $ to get customers, who use the credits and then leave.

Manus is running $5000 credit for 2000 people. A simple search shows so many offers: https://x.com/search?q=ManusAI%20credits&src=typed_query

Each of the players are just eating each others customers and showing growth. Perplexity has acquired who knows how many customers in India through their 12 month free Pro offer via Airtel (a telecom provider): https://www.perplexity.ai/help-center/en/articles/11842322-p...

Lovely project. Also @rubenvanwyk mentioned SlateDB. I am not sure if this will fit my use-case but, today, I was looking for data hosting options for a self-hosted LLM+bot for email/calendar.

I have this product I have tried and stopped before: https://github.com/pixlie/dwata and I want to restart it. The idea is to create a knowledge graph (use Gliner for NER). Compute would either be on desktop or cloud (instances).

Then store the data on S3 or Cloudflare Workers KV or AWS Dynamo DB and access with cloud functions to hook up to WhatsApp/Telegram bot. I may stick with Dynamo or Cloudflare options eventually though (both have cloud functions support).

I need a persistent storage of key/value data (the graph, maybe embedding) for cloud functions. Completely self-hosted email/calendar bot with LLM, own cloud, own API keys. Super low running cost.

I simply ask Claude Sonnet, using claudecode, to use opencode. That's it! Example:

  We need to clean up code lint and format errors across multiple files. Check which files are affected using cargo commands. Please use opencode, a coding agent that is installed. Use `opencode run <prompt>` to pass in a per-file prompt to opencode, wait for it to finish, check and ask again if needed, then move to next file. Do not work on files yourself.

I do not spend $100/month. I spend for 1 Claude Pro subscription and then a (much cheaper) z.ai Coding Plan, which is like one fifth the cost.

I use Claude for all my planning, create task documents and hand over to GLM 4.6. It has been my workhorse as a bootstrapped founder (building nocodo, think Lovable for AI agents).

Companies are lazy. Big ones are lazy and scared to not have someone to hold accountable.

I am using GPL 3.0 mostly from a business standpoint, so that I can sell a commercial license to companies that may want to modify the project. In really LLMs will launder everything they can, I am not sure if that can be stopped. So that affects every project. The reason why LLMs are as good is that they train on all code that is available.

I use LLMs to generate almost all my code. Currently at 40K lines of Rust, backend and a desktop app. I am a senior engineer with almost all my tech career (16 years) in startups.

Coding with agents has forced me to generate more tests than we do in most startups, think through more things than we get the time to do in most startups, create more granular tasks and maintain CI/CD (my pipelines are failing and I need to fix them urgently).

These are all good things.

I have started thinking through my patterns to generate unit tests. I was generating mostly integration or end to end tests before. I started using helping functions in API handlers and have unit tests for helpers, bypassing the API level arguments (so not API mocking or framework test to deal with). I started breaking tasks down into smaller units, so I can pass on to a cheaper model.

There are a few patterns in my prompts but nothing that feels out of place. I do not use agents files and no MCPs. All sources here: https://github.com/brainless/nocodo (the product is itself going through a pivot so there is that).

Halfway through I realized where this is going. Could not hold the tears. These are tough choices. My parents are alive, getting older. My dad has fairly serious mental health issues. Life has never been easy in a very dysfunctional family. I stayed away from family for many years. Now, I am 41 and these last few years, I have started to realize that I may not have much time with them.

We are busy people but no matter how we try, we cannot bring people back. We cannot make some things different. I think about that a lot. Even coming from a family of abuse and trauma that needed a decade of counseling and healing, I still feel sad they may not be there much longer.

Thank you for a reminder. Thank you for sharing your personal story.

The skills approach is great for agents and LLMs but I feel agents have to become wider in the context they keep and more proactive in the orchestration.

I have been running Claude Code with simple prompts (eg 1) to orchestrate opencode when I do large refactors. I have also tried generating orchestration scripts instead. Like, generate a list of tasks at a high level. Have a script go task by task, create a small task level prompt (use a good model) and pass on the task to agent (with cheaper model). Keeping context low and focused has many benefits. You can use cheaper models for simple, small and well-scoped tasks.

This brings me to skills. In my product, nocodo, I am building a heavier agent which will keep track of a project, past prompts, skills needed and use the right agents for the job. Agents are basically a mix of system prompt and tools. All selected on the fly. User does not even have to generate/maintain skills docs. I can get them generated and maintained with high quality models from existing code in the project or tasks at hand.

1 Example prompt I recently used: Please read GitHub issue #9. We have phases clearly marked. Analyze the work and codebase. Use opencode, which is a coding agent installed. Check `opencode --help` about how to run a prompt in non-interactive mode. Pass each phase to opencode, one phase at a time. Add extra context you think is needed to get the work done. Wait for opencode to finish, then review the work for the phase. Do not work on the files directly, use opencode

My product, nocodo: https://github.com/brainless/nocodo