fb4a88867a feat: self evolving skills (#150)
* feat(skills): extend GenerateSkillSpec with full_index_js and update generator

- Add optional `full_index_js` field to GenerateSkillSpec so LLM-generated
  JS source can be written verbatim instead of using the default template
- Change generate_alphahuman() return type from PathBuf to Vec<PathBuf>
  (returns both manifest.json and index.js paths for audit logging)
- Add UnifiedSkillRegistry::skills_dir() and engine() helper accessors
  needed by the self-evolve orchestrator

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* feat(skills): add isolated QuickJS skill tester with mock bridge globals

Introduces SkillTester::run_isolated() which spins up a fresh rquickjs
context (no shared state), injects no-op mock globals for all bridge APIs
(db, net, state, platform, cron, skills), loads index.js, and calls
init/start plus each tool's execute() with empty args.

The test passes only if every exported tool returns without throwing and
produces valid output. Used by the self-evolve loop to validate generated
code before registering it into the live registry.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* feat(skills): add LLM code generator using Anthropic Claude API

Introduces LlmGenerator with two methods:
- generate_spec(task): first-pass generation from a natural-language task
  description; produces a complete GenerateSkillSpec including full_index_js
- fix_spec(task, prev_code, error): retry pass that feeds the previous
  code and the test error back to the model for correction

Uses claude-3-5-haiku-20241022 via direct reqwest POST to the Anthropic
messages API. System prompt teaches the model the exact QuickJS index.js
format, available bridge globals, and synchronous net.fetch semantics.
Strips markdown code fences from the response before use.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* feat(skills): add self-evolve orchestrator with iteration loop and audit log

Introduces SkillEvolver::evolve() which implements the full pipeline:
  1. LLM generates a GenerateSkillSpec from a task description
  2. generator::generate_alphahuman() writes manifest.json + index.js
  3. SkillTester::run_isolated() validates the code in a fresh sandbox
  4. On failure: feed error back to LLM and regenerate (up to max_iterations)
  5. On success: discover_skills() + start_skill() to register live, then
     execute() to run the real task and capture final output
  6. Returns SelfEvolveResult with full audit log, files_created, and
     the final UnifiedSkillResult

Wraps the entire evolve() call in tokio::time::timeout (default 120s).
Cleans up written skill directory on permanent failure so no partial
skill is left registered.

Key types:
  SelfEvolveRequest  — task_description, max_iterations, timeout_secs,
                       optional anthropic_api_key override
  SelfEvolveResult   — skill_id, success, iterations_used, audit_log,
                       files_created, final_result, failure_reason
  IterationLog       — per-iteration code, test output, pass/fail flag

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* feat(tauri): register unified_self_evolve_skill command with progress events

Adds unified_self_evolve_skill Tauri command that:
- Accepts a SelfEvolveRequest (task_description + optional limits)
- Emits skill:evolve:progress event after each iteration so the frontend
  can show live progress without polling
- Delegates to SkillEvolver::evolve() and returns SelfEvolveResult
- Mobile stub returns an informative error (feature requires desktop runtime)

Registers the command in generate_handler![] in lib.rs.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* feat(ui): add SelfEvolveModal and Auto-Generate button to SkillsGrid

SelfEvolveModal (src/components/skills/SelfEvolveModal.tsx):
- createPortal modal with 4 states: idle / running / success / failed
- Text input for natural-language task description
- Calls unified_self_evolve_skill via invoke() on submit
- Subscribes to skill:evolve:progress Tauri events to show live iteration
  updates (iteration number, pass/fail indicator)
- On success: displays audit log accordion with per-iteration code,
  test output, and final task result
- On failure: shows failure reason and full audit trail for debugging
- Calls onSkillCreated() callback to trigger grid refresh

SkillsGrid changes:
- Add selfEvolveOpen state + "Auto-Generate" button in the toolbar
- Extract refreshSkills as a named async function reused by both the
  initial load and the SelfEvolveModal's onSkillCreated callback
- Add activeSkillType state so SkillSetupModal shows the correct badge
  when opened from either the Connect or Manage flow

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix(skills): fix alphahuman skill template and generation pipeline

- generator.rs: use bare `tools = []` (not const) for globalThis access,
  add `execute: async function(args)` method, fix `input_schema` casing
- mod.rs: call start_skill() after generate() so skills are immediately executable
- llm_generator.rs: update model to claude-haiku-4-5-20251001, sync system prompt

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix(skills): fix tools not loading for generated skills and add robustness fixes

- llm_generator: require 'var tools = [...]' in system prompt (const/let are
  block-scoped and do not attach to globalThis, causing extract_tools() to find
  an empty array in the production QuickJS engine)
- llm_generator: add smart_name() — deterministic display name from task
  description (strips preambles + lead fillers + stop words, title-cases 3
  tokens); replaces brittle LLM-dependent naming
- llm_generator: improve sandbox testing rules in system prompt so placeholder
  values prevent test failures when net.fetch returns empty JSON
- skill_tester: detect {error: '...'} return values as test failures (both sync
  and Promise paths) so the iteration loop attempts a fix instead of treating
  them as success
- manager.ts: dispatch setSkillSetupComplete(true) for skills without a setup
  flow so deriveConnectionStatus() returns "connected" instead of "connecting"

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-02-26 19:58:42 +04:00
2026-02-04 18:05:04 +05:30
2026-02-26 19:55:53 +04:00
2026-02-20 13:03:15 +04:00
2026-02-26 19:55:53 +04:00
2026-02-26 19:58:42 +04:00
2026-02-11 02:50:50 +05:30
2026-02-26 19:56:25 +04:00
2026-02-26 19:55:53 +04:00
2026-02-20 13:03:15 +04:00
2026-02-20 13:03:15 +04:00
2026-02-16 17:10:06 +05:30
2026-02-03 15:26:38 +05:30
2026-02-20 13:03:15 +04:00
2026-02-20 13:03:15 +04:00
2026-02-20 13:03:15 +04:00
2026-02-03 15:26:38 +05:30
2026-02-16 17:10:06 +05:30
2026-02-16 17:10:06 +05:30
2026-02-16 17:10:06 +05:30
2026-02-26 19:58:21 +04:00

AlphaHuman Mk1

Your most productive co-worker
A user-friendly (GUI-first) AI agent. AlphaHuman uses the Neocortex Mk1 model to co-ordinate memories & realtime-data, cheaper and faster than other models.

Early Beta Platforms Latest Release

About · vs OpenClaw · Download · Getting Started · Architecture · Changelog

The Tet

"The Tet. What a brilliant machine" — Morgan Freeman in Oblivion

AlphaHuman is a personal AI assistant that helps you manage high-volume communication without reading everything yourself. It connects to your messaging platforms and productivity tools, understands conversations in context, and produces clear, actionable outputs you can use immediately.

AlphaHuman is not a chatbot, browser extension, or cloud-only service. It is a native application that runs on your device, connects to your tools, and works only when you ask it to. Think of it as a second brain that sits across your communication and productivity stack.

AlphaHuman vs OpenClaw

AlphaHuman is designed to be simpler to deploy, cheaper to run, and more intelligent in how it uses models and memory.

OpenClaw AlphaHuman
Runtime Node.js (TypeScript) Tauri (Rust + React), native binary
Inference Single-tier or manual routing Custom two-tier: task-routed (summarize/vibe/memory → cheap; complex/tools → premium)
Memory Often external (Pinecone, Lucid, etc.) or markdown-only Custom hybrid: SQLite FTS5 + vector similarity, optional encryption, no external vector DB
Tunneling Third-party (ngrok, Cloudflare, Tailscale) or none Custom tunneling — secure app-to-backend path without vendor lock-in
Cost Typically one premium model for everything Lower — Tier 1 for most ops; Tier 2 only when needed
Intelligence General-purpose agent loop Smarter — vibe detection, interest-based escalation, constitution-driven behavior, session-aware memory
Deployment Server/Node process, high memory footprint Native desktop/mobile app, Rust socket manager, smaller footprint

OpenClaw is a strong open-source agent framework. We chose to build a custom stack so we could own inference routing, memory, and tunneling end-to-end and optimize for cost and clarity.


Download

Early Beta — AlphaHuman is under active development. Expect rough edges.

Platform Variant Download
macOS Apple Silicon (M1/M2/M3/M4) .dmg (aarch64)
macOS Intel .dmg (x64)
Windows x64 .msi
Linux Debian / Ubuntu .deb (amd64)
Linux Fedora / RHEL .rpm (x86_64)
Linux Universal .AppImage
Android Coming soon
iOS Coming soon

Browse all releases: github.com/alphahumanai/alphahuman/releases

Getting Started

  1. Download the installer for your platform from the releases page
  2. Install the app (drag to Applications on macOS, or use your package manager on Linux)
  3. Connect a source — follow the in-app onboarding to link Telegram, Notion, Gmail, or other services
  4. Run your first request — ask the AI to summarize what you missed, extract action items, or surface key decisions


Made with love in India 🇮🇳

AlphaHuman is in early beta. Features may change, break, or disappear. Use at your own risk.

S
Description
No description provided
Readme GPL-3.0
214 MiB
Languages
Rust 59.1%
TypeScript 37.9%
JavaScript 1.6%
Shell 1.2%
CSS 0.1%