Inno Agent
An open-source personal learning agent with three-layer memory (learner profile / wiki knowledge base / cross-conversation recall), a proactive scheduler, personal IM channels, and a Practice Lab — built on the Pi SDK without modifying its kernel.
Trust scores are conservative. Least_privilege(1): the agent runs bash, files, a WebSocket terminal, IM channels and cron with OS sandbox only optional (pi-sandbox, requires ripgrep); deducted for non-sandboxed default. User_confirmation(1): `closeBehavior: ask` and 409 blocker details exist, but no described confirmation gate for dangerous bash/file writes. Data_flow_transparency(2): memory writes are stated to go through inspectable/editable tools (L1), architecture and layout are clear; deducted for describing flows only at README level with no code-level audit-log evidence. Sensitive_data_handling(1): API keys sit in plaintext config. which the server hot-rewrites; showcase export claims sanitization but runtime protections lack evidence. Dependency_security(1): npm overrides pin axios and xlsx is vendored — some care shown, but no audit policy and transitive Pi SDK deps unassessed. External_effects(1): proactive messaging to Feishu/WeChat/QQ, scheduled jobs, workspace writes — broad effects with unspecified default authorization. Rollback(1): no update/rollback mechanism described; the server hot-rewrites config with no backup mentioned. Source_attribution(2): Pi SDK (Mario Zechner, MIT) properly credited, honest 'kernel never modified' claim, citation block present; deducted because publisher is registry-unverified and macOS builds are unsigned.
Self_consistency(2): the Non-goals section explicitly states single-process/no-multi-tenant constraints consistent with the architecture; deducted because the root README says no test runner is wired up while the release workflows run vitest as a gate — a mild, possibly temporal, tension. Dependency_availability(2): Content Hub has local caching plus bundled offline presets, showing remote-unavailability design; deducted because the default hub is a third-party repo outside the maintainer's control. Failure_messages(2): 409 session_busy with blocker details surfaced to the UI is a concrete, designed failure path; deducted because it is the only documented instance and no unified error-handling policy is described.
Audience_and_scenarios(3): an exceptionally clear single-learner positioning with a 'Why' stance, explicit non-goals, Simple Mode presets for non-technical users, and use-case docs — full marks justified. Capability_boundaries(2): concurrency/multi-user boundaries are well drawn, but the agent's operational limits (what it may execute) are thinly described. Trigger_precision(1): L3 recall is called 'threshold-gated' and cron is natural-language, but threshold values and false-trigger handling have no static evidence; environment trigger conditions are undefined. Environment_fit(2): three-tier path resolution (flag > env > default), Docker, three delivery forms, Node >=20.6 engines — good coverage; deducted for unexplained platform dependencies (WeChat bridge modes, ripgrep scattered across docs).
Information_architecture(3): README → QUICKSTART → backend README → docs/ layering, layout table, route table, and deployment layout are all present — full marks. Install_notes(3): three install paths with complete commands, a config template, and API-key steps, plus a dedicated system-dependency doc. Naming_stability(2): `inno` CLI, package names and path conventions are consistent, but the project is at 0.5.x and the default provider name 'innospark' against an example baseUrl is mildly confusing; no stability commitment stated. Examples_and_faq(2): QUICKSTART, skill tutorial and use-cases exist; no general FAQ or product-level troubleshooting beyond the showcase handbook. Known_limitations(3): the Non-goals section is a textbook limitations statement with a design-discussion issue link — full marks. License(3): full MIT text in-repo with dependency licensing noted. Versioning_changelog(2): semver tag-driven release workflows with prerelease rules are complete, but no CHANGELOG file or per-version change notes are shown. Maintenance_responsibility(1): Contributing section and a WeChat community group exist, but there is no governance, maintainer list, or response commitment; long-term maintenance path is unclear for a personal repo.
Output_usability(2): traceable tool-writes to L1/L2, session replay, i18n and themes show output designed for the learning use case; deducted because these are claims with no static mechanism detail on output-quality constraints. Marginal_value(2): 'layered memory over flat chat summary' and 'durable facts go to tools' form a genuine differentiation argument against general coding agents, with an intended technical report; deducted because the differentiated effect cannot be statically verified. Cost_benefit(2): the deliberately single-process architecture reduces complexity and local models (Ollama) can control spend; deducted that the Electron + full-stack + SQLite footprint is not light for a personal companion, users bear LLM API costs, and no cost estimate is given.
Claim_traceability(2): design decisions link to issue #124, doc paths are concrete and checkable, release workflows gate on vitest; deducted because headline claims (three-layer memory benefit, L2 retrieval quality) lack statically checkable data in-scope — the eval script exists but no results are shown. Cross_source_corroboration(1): an arXiv report, a third-party hub repo and the Pi SDK npm package are referenced, but all fall outside this review's scope and cannot be corroborated; deducted for lack of an independent second source within scope. Fact_inference_separation(2): Non-goals and stance sections clearly separate factual constraints from design positions, and the showcase's 'real UI' claim has a code-level mechanism; deducted for marketing-style phrasing ('real session', future-dated artifacts) unverifiable statically.
- The OS sandbox is optional and off by default; bash/file/terminal capabilities run unrestricted — enable `server:sandbox` and isolate the workspace directory in personal deployments.
- API keys are stored in plaintext config., which the server hot-rewrites; watch file permissions and backups.
- The default Content Hub is a third-party repo (Chloris-Blaxk/inno-agent-hub); imported skills/presets are unreviewed — self-host or audit before use.
- There is no auth model and no tenant isolation; never expose the web port publicly or share an instance across users.
- macOS builds are unsigned and the publisher is not registry-verified; verify build provenance before installing.
- Proactive IM channels (Feishu/WeChat/QQ) send messages to external services; confirm authorization scope and messaging costs before enabling.
- The claimed vitest release gate conflicts with the root README's 'no test runner wired up' note — verify critical behavior yourself.
What does this agent do, and when should you use it?
Inno Agent is an open-source learning agent for a single learner that organizes long-term support into three explicit memory layers: an L1 learner profile, an L2 native wiki knowledge base, and L3 session records with cross-conversation retrieval. It ships in three forms sharing the same runtime state: an Electron desktop app, a React 19 Web UI (Node HTTP server with SSE streaming, terminal, wiki graph), and a pure-TUI terminal CLI (inno). The learning loop is completed by a cron scheduler, personal IM channels (Feishu / WeChat), and a Practice Lab with an in-browser terminal. All learning behavior is added through registered tools and one before_agent_start extension hook, leaving the Pi SDK kernel untouched and upstream-compatible. The project is MIT-licensed, supports Docker deployment, and is deliberately scoped to one process, one active session, and no multi-user concurrency.
On each turn, a before_agent_start hook compresses the evidence-driven L1 profile (goals, knowledge states, misconceptions, preferences) into a context pack injected into the system prompt, alongside threshold-gated L3 recall over a SQLite FTS5 index. Durable facts are written to L1/L2 via tools; the L2 wiki offers hybrid retrieval (lexical BM25 + knowledge graph), LLM-assisted summarization, and PDF/Office/image ingestion. Cron jobs created in natural language persist to jobs. and runs.l and can fire from the agent, the UI, or the daemon, dispatched through a unified dispatcher to Feishu (native), WeChat (iLink QR login or bridge mode), and QQ (bridge). The Practice Lab runs code in a workspace-scoped xterm.js WebSocket terminal and records runs the agent can read. Skills and Simple Mode presets are imported from a remote content hub (default: the Chloris-Blaxk/inno-agent-hub GitHub repo, or a self-hosted bundle service), and real sessions can be exported to a standalone replay site (apps/showcase).
- An individual learner preparing for exams or a new field: the agent tracks your knowledge state and misconceptions in the L1 profile and proactively pushes review reminders to WeChat or Feishu via cron schedules.
- A learner building a long-term personal knowledge base: ingest PDFs, Office documents, and images into the L2 wiki, then query the agent in natural language with graph-aware hybrid retrieval.
- Users who want to learn by writing and running code mid-conversation: run code in the Practice Lab's browser terminal; run records feed back into the agent's feedback loop.
- Non-technical users: import one-click preset workspaces (lesson plan, PPT creation, scenario explain) via Simple Mode without manual setup.
- Privacy- and explainability-minded learners: the L1 profile is inspectable and editable, unevidenced labels are forbidden, and all data stays in local runtime directories.
- Developers customizing teaching flows: build a workspace-scoped custom learning agent with agent.md and .skills/, or self-host the content hub.
What are this agent's strengths and limitations?
- Layered memory instead of a flat chat summary: L1/L2/L3 have distinct lifecycles in separate stores, and personalization is evidence-driven through tools, making it traceable.
- The Pi SDK kernel is never modified — all capabilities are added through registered tools and one before_agent_start hook, keeping the runtime upstream-compatible and easy to track.
- An open, correctable learner model: the L1 profile is inspectable and editable by the learner, with unevidenced labels explicitly forbidden.
- Three forms (desktop / web / CLI) share one runtime state, plus a session replay site (apps/showcase) that reproduces recorded sessions through the real product UI.
- Deliberately single-process with one active agent session: a single in-memory prompt queue serializes all work, and cross-session operations return 409 session_busy when busy — unsuitable for teams or concurrent tasks.
- No multi-user concurrency, no horizontal scaling, no auth model or tenant isolation; team deployment requires one instance per person.
- No lint/test runner is wired up — contributions are sanity-checked only by the TypeScript build, limiting engineering guarantees.
- Depends on the Pi SDK ecosystem (@earendil-works/pi-* packages by Mario Zechner) and an external LLM API key; the optional sandbox additionally requires ripgrep.
- The cited technical report is dated June 2026 (arXiv), and parts of the ecosystem (content hub, community) rely on third-party repos and WeChat groups.
How do you install or deploy this agent?
Option A (easiest): download an installer from GitHub Releases — macOS Apple Silicon: Inno.Agent-x.y.z-arm64.dmg (unsigned; right-click → Open on first launch), Windows x64: Inno.Agent.Setup.x.y.z.exe or .msi. Option B (from source): git clone https://github.com/hhyqhh/inno-agent.git && cd inno-agent && npm install && npm run build, then mkdir -p runtime/config runtime/data runtime/skills workspace, cp config.example. runtime/config/config. and set providers[*].apiKey. Option C (Docker): docker compose up -d (port 3000, mounts runtime/ and workspace/). Requires Node.js >= 20.6.0 and a provider endpoint/key speaking openai-completions or anthropic-messages (Anthropic, OpenAI, DeepSeek, Ollama, or local models).
How do you use this agent?
Run npm run server for the Web UI (:3000), npm run start for the terminal CLI, npm run electron for the desktop app, or npm run server:sandbox with the OS-level sandbox (requires ripgrep). On first launch a default config is created at ~/.inno-agent/config/config. — add your provider API key there or via in-app settings. Redirect paths with CLI flags (--home, --config-dir, --data, --skills, --workspace, --port) or INNO_* env variables. In the UI you can hot-switch models, toggle L1/L2/L3 memory layers, and enable Feishu/WeChat channels (channels.feishu.enabled, channels.wechat.enabled). Ask the agent in natural language to create review schedules (cron jobs); export a session for replay via the clapperboard icon in the sidebar or npm run showcase:export -- --session <substring>.