Skip to content

Projects

Case study

Meera

Local AI operating layer that plans, executes tools, and verifies outcomes instead of trusting the model’s word.

BuiltOriginal work

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

  1. 01

    User

    Terminal UI

  2. 02

    Intent router

    src/router.js

  3. 03

    Runtime state

    Live context + session

  4. 04

    Agent loop

    Adaptive execution for agent tasks

  5. 05

    Planner

    Capability lookup

  6. 06

    Validate

    Schema and parameters

  7. 07

    Permission gate

    Safety before action

  8. 08

    Execute

    Real tools

  9. 09

    Verify

    Confirm the world changed

  10. 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

github.com/Kishore-3021/Meera

No public demo listed.