Case study
Meera
Local AI operating layer that plans, executes tools, and verifies outcomes instead of trusting the model’s word.
Local AI · Agents · LLM
01 / Overview
Open-source local AI operating layer powered by Qwen and Ollama, focused on reasoning, search, tool execution, verification, and an extensible tool ecosystem.
- Node.js
- Ollama
- Qwen 2.5
- SearXNG
- Playwright
- SQLite
- pywinauto
02 / Problem
Most local assistants wrap a chat model and treat the model’s claim as the outcome. If the model says a browser opened or a file was written, nothing in the system has verified that the world actually changed.
03 / Approach
Meera is an operating layer, not a chatbot wrapper. It routes intent, plans against a capability registry, validates parameters, requires permission where needed, executes real tools, and checks the result before reporting success. Planner output is never treated as proof of execution.
04 / Architecture
01
User
Terminal UI
02
Intent router
src/router.js
03
Runtime state
Live context + session
04
Agent loop
Adaptive execution for agent tasks
05
Planner
Capability lookup
06
Validate
Schema and parameters
07
Permission gate
Safety before action
08
Execute
Real tools
09
Verify
Confirm the world changed
10
SQLite
Audit and knowledge
A persistent-agent layer (background awareness, event bus, self-model) is described in the repository as planned, not as the current default path.
05 / Implementation
- Terminal UI with streaming responses, tool status, and confirmation prompts (src/index.js, terminal-ui.js).
- Intent router that sends chat/web/memory/code paths to Ollama + Qwen 2.5, and agent tasks into an adaptive loop.
- Capability registry, planner, executor, and permission modules under src/tools/.
- SearXNG (Docker) for local web search; Playwright for browser automation; pywinauto / PyAutoGUI for native GUI control.
- SQLite for routing audits, tool logs, and FTS knowledge search.
- Test scripts covering router behavior, tool schemas, permissions, files, desktop automation, planner logic, and multi-step flows.
06 / Engineering decisions
- Verification over confidence
- The system’s non-negotiable rule is that a plan is not evidence. Success requires execute + verify. That is the difference between an agent demo and an operating layer.
- Local-first routing
- Authoritative local state is preferred over web search. “What GPU do I have?” should hit the machine, not a search engine. External search is a later fallback via self-hosted SearXNG.
- Registry instead of ad-hoc tools
- Tools are registered capabilities with schemas, not prompt-described functions. The README documents a large registry whose live availability depends on OS, config, and credentials.
- Test the machine, not the story
- Reliability is framed as “the machine confirms it worked,” with tests around validation, permissions, and execution rather than around generated prose.
07 / Evaluation
Evaluation data has not yet been benchmarked. The repository includes tests for routing, tools, and multi-step flows; no published latency, success-rate, or user-study numbers.
08 / Limitations
- Persistent-agent architecture (awareness loop, resumable state, self-model) is planned, not the current default.
- Native GUI automation is Windows-oriented (pywinauto); capability availability depends on local dependencies.
- Bound by local model quality (documented primary model: qwen2.5:7b-instruct-q4_K_M).
- No independent production deployment claim.
09 / Repository
No public demo listed.