DEV Community: Ángela López Mendoza

Lets install Tlamatini v1.17.1...

Ángela López Mendoza — Sat, 06 Jun 2026 23:33:35 +0000

Install Tlamatini v1.17.1 at: Tlamatini v1.17.1

Checkout Tlamatini's release v1.17.0!

Ángela López Mendoza — Sat, 06 Jun 2026 16:25:07 +0000

Tlamatini's Release v1.17.0

Check our new English/Spanish website!

Ángela López Mendoza — Sat, 06 Jun 2026 16:19:22 +0000

https://xaiht.org

Learn how to make security enhancements with an AI assistant (Tlamatini).

Ángela López Mendoza — Tue, 02 Jun 2026 13:11:39 +0000

Just check this video, now I don't need to pay for a first evaluation of every application I make, I use Tlamatini, check at it: Code Assessment and Enhancement

Stop chasing parameter counts. Build the toolbelt instead. — What I learned building Tlamatini (Open Source Destktop App).

Ángela López Mendoza — Tue, 02 Jun 2026 04:57:16 +0000

For the last few months I've been building Tlamatini, an open-source local-first AI developer assistant. Along the way I kept bumping into the same assumption — both in articles and in my own head — that to build something useful, you need the biggest model you can afford. GPT-4. Claude Opus. Llama 70B at minimum.

Then I started actually shipping with smaller local models, and I learned something that flipped my thinking.

The real lesson

A 20B-parameter LLM, given the right tools, the right agents, and skills fine-tuned to your operating procedures, is good enough to power most of your company's real workflows.

Parameter count is not the bottleneck. The bottleneck is whether the model can act — and that's a tools problem, not a parameters problem.

What "the right tools" actually means

In Tlamatini, we wired the LLM into 75 concrete capabilities:

Shell and Python execution
File operations
Browser automation (Playwright)
Screenshots and keyboard/mouse control
Email, Telegram, WhatsApp bridges
A hybrid RAG pipeline (FAISS + BM25) so the model sees the right code, not random chunks
Multi-agent orchestration via ACPX — the assistant can delegate sub-tasks to Claude Code, Cursor, Codex, or Gemini CLI and relay output between them

With this toolbelt, a 20B model running locally on Ollama can:

Read your codebase and answer accurate questions about it
Refactor a module, run the tests, and report back
Open a browser, fill a form, screenshot the result
Build and flash firmware to an STM32 microcontroller (yes, really)
Chain all of the above into a single conversation

A 200B cloud model with no tools cannot do any of those things.

Why this matters for companies

Most internal AI projects fail because teams reach for the biggest model and the smallest scope. They get an expensive chatbot that drafts emails.

Flip it: give a modest model a real toolbox and skills fine-tuned to your actual operating procedures (your CRM, your ticketing system, your build pipeline), and you get an operator — something that participates in the workflow instead of describing it.

Local 20B + tools > cloud 200B + chat box. Almost every time.

The practical takeaway

If you're thinking about adopting AI in your company and the budget conversation is stuck on which API to pay for, consider stepping back:

What are your repeatable operating procedures?
What tools would an agent need to actually execute them?
Can you wrap those tools cleanly enough that a local 20B model can call them reliably?

If yes, you don't need to send anything to the cloud. You don't need to pay per token. You don't need permission from a vendor. You just need to build the toolbelt.

That's what Tlamatini is — an open-source toolbelt and orchestration layer for local LLMs. Built in Django, runs on Ollama, GPL-3.0.

GitHub: github.com/XAIHT/Tlamatini
One-minute demo: youtu.be/4MyRXBahHuU

I'd love to hear from other people who've shipped agent systems on smaller local models — what's working for you? What's still painful? What tools made the biggest difference?

She is Tlamatini — this is how she looks in the Metaverse.

Ángela López Mendoza — Sun, 31 May 2026 21:16:59 +0000

I built a local-first AI dev assistant with 68 agents in Django — here's what I learned

Ángela López Mendoza — Wed, 27 May 2026 22:57:09 +0000

I've spent months building Tlamatini (Nahuatl for "one who knows") — a locally-deployed AI developer assistant that goes way beyond a chatbox. It runs on your machine with Ollama, your code never leaves your box, and it's fully open source (GPL-3.0).

I want to share what I built and what I learned, because building a local-first AI tool as a solo developer taught me things I didn't expect.

What Tlamatini does

Most AI coding assistants are cloud-first chatboxes. Tlamatini is different:

Hybrid RAG over your codebase — FAISS + BM25 retrieval with Reciprocal Rank Fusion and context budgeting. The model doesn't just see random code chunks — it sees the right code, ranked and budgeted so it fits in context.

Multi-Turn mode with 75 tools — The LLM becomes an operator. Shell commands, Python execution, file operations, browser automation with Playwright, screenshots, keyboard/mouse control, email, Telegram, WhatsApp — all chained in one conversation. You tell it what you want done, and it figures out the steps.

ACPX (Agent Communication Protocol eXtension) — This is the part I'm most proud of. Tlamatini can spawn external coding-agent CLIs — Claude Code, Cursor, Codex, Gemini CLI, Qwen — as child processes, send them tasks, and relay output between them. One orchestrator, multiple coding agents, working on different parts of a problem simultaneously.

Visual Workflow Designer — A drag-and-drop canvas with 68 agent types. Wire them together, validate the flow, run it unattended. Save flows as .flw files, schedule them, monitor them with FlowHypervisor.

Self-aware architecture — Tlamatini carries a first-person knowledge map of her own architecture (Tlamatini.md) that's injected into every LLM prompt. She can answer questions about herself accurately. Builds packaged with --self-modify ship her own source tree so she can read, inspect, and modify herself.

The tech stack

Backend: Python 3.12, Django 5.2, Django Channels (Daphne ASGI)
AI/ML: LangChain 0.3, LangGraph 0.2, FAISS, rank-bm25
LLM backends: Ollama (local default), Anthropic Claude (cloud opt-in), Qwen (vision)
Communication: WebSockets for real-time streaming, gRPC for MCP services
Database: SQLite
Packaging: PyInstaller → one-click Windows .exe installer

Lessons learned building this solo

1. RAG is harder than it looks

Everyone shows RAG demos with 5 documents. Try it with a real codebase — thousands of files, mixed languages, config files, migrations, tests. The naive approach (chunk everything, embed, retrieve top-k) falls apart immediately.

What worked: hybrid retrieval (dense vectors from FAISS + sparse matching from BM25), Reciprocal Rank Fusion to combine rankings, code-aware metadata extraction so the retriever knows which file, class, and function each chunk belongs to, and context budgeting so I never blow the model's context window.

2. Multi-agent orchestration needs contracts

When you have 68 agent types that can be wired together in any combination, you need a formal system for "what can connect to what." I built an Agent Contract registry — each agent declares its connection fields, parameter sources, secret paths, and validation rules. The Flow Compiler validates every connection before execution.

Without this, users would wire agents together in invalid ways and get cryptic errors at runtime. With contracts, validation happens at design time on the canvas.

3. Process management on Windows is brutal

Tlamatini spawns child processes for agents, ACPX CLIs, and tool execution. On Windows, every subprocess gets a conhost.exe companion. These pile up and orphan when the parent dies. Users saw dozens of Tlamatini-icon processes in Task Manager.

I built a three-tier orphan reaper: Tier 1 runs after every tool call, Tier 2 runs after the LLM response, Tier 3 runs at shutdown. Plus a monkey-patch on subprocess.Popen that defaults CREATE_NO_WINDOW so future tools get the fix for free.

4. Local-first is a feature, not a limitation

The decision to make Ollama the default (not Claude API, not OpenAI) was controversial in my head. Cloud models are smarter. But local-first means: your code never leaves your machine, no API costs for basic usage, works offline, and no vendor lock-in.

Users who want cloud quality can opt in per-request. But the default is private. In 2026, that matters.

Try it

GitHub: github.com/XAIHT/Tlamatini
One-minute demo: youtube.com/watch?v=4MyRXBahHuU
Stack: Django 5 + Channels, LangChain, FAISS, Ollama. GPL-3.0.

Five-minute setup: clone, pip install, migrate, runserver. That's it.

I'd love feedback — especially on the RAG architecture and the ACPX multi-agent orchestration. What would you add? What would you do differently?