OpenAya OS

I°

Loading...

v2.0 — Self-improving AI

Open Aya OS — the agentic, in-browser cognitive operating system.

Open Aya uses a CAISI-inspired evaluation framework to measure capability, cost, latency, auditability, and workflow lift across baseline models, the Aya Pipeline, and reasoner routes. The goal is not to claim AGI; the goal is to prove whether an AI operating layer completes organizational work better than fragmented AI tools.

28 integrated apps. Voice-native, vision-aware, local-first with optional cloud sync. Multi-agent routing across planner, executor, memory, verifier, and critic strategies — every step auditable through a public benchmark harness, not a brochure.

Open Aya OS

Intelligence Card

Live system facts. Every number on this card is generated at request time from the runtime registry or the public eval database — there is no separate marketing source to drift.

Live

Model layer

  • anthropic/claude-sonnet-4.6 (conversation tier)
  • anthropic/claude-opus-4.6 (extended thinking, 10k budget)
  • google/gemini-3-flash (multimodal)
  • anthropic/claude-opus-4.6 (SWE-Bench leader)

Agent layer

6 routed strategies: planner, executor, memory_retriever, verifier, router, self_critic

Strategy-Auction routing implemented as system-prompt routing rules

Memory layer

Supabase + browser IndexedDB (local-first)

Kinds: short-term turn cache · long-term Auto-Dream consolidation · GraphRAG knowledge edges

Tool layer

6 built-in tools across 28 apps

Web search · Code execution (Code Lab) · File store (Spatial Files) · Calendar / Notes / Word Processor · …

Local-first status

Yes — runs in-browser; data stays on device by default

Cloud sync status

Optional — Supabase auth + persistence when signed in

Apps in registry

28

Generated from lib/app-registry.ts

Routed agents

6

Strategy-auction policies, system-prompt routed

Eval score (avg)

—

Across 0 completed runs

Last eval run

no runs yet

UTC server time

Avg latency / task

—

Wall-clock, includes network hop

Audit mode

Public — every eval result writes a reasoning trace to /api/aya/inspect and aggregates to /api/aya/audit

A/B comparison — pass rate by route

baseline

—

Claude Sonnet 4.6, no spine (control)

aya_pipeline

—

Claude Sonnet 4.6 + 7-stage cognitive spine

aya_reasoner

—

Claude Opus 4.6, extended thinking (10k)

What you can verify, right now, without an account.

  • Public eval API. /api/evaluate accepts a prompt and returns the canonical result shape (task_id, category, answer, agents_used, confidence, latency_ms, cost_estimate, memory_used, audit_trace).
  • Public status JSON. /api/aya/status lists every capability flag with an honest functional / claimed marker — no inference required.
  • Public audit aggregates. /api/aya/audit publishes the A/B verdict between baseline Claude Sonnet 4.6, Aya's 7-stage cognitive pipeline on anthropic/claude-sonnet-4.6, and the anthropic/claude-opus-4.6 reasoner (extended thinking, 10k budget) across all completed runs.
  • Three live demos. Reasoning, memory, and agent routing run a canned task end-to-end and show the full reasoning trace.
  • No claim without a receipt. Every superlative on this site links to a reproducible run with a JSON trace. Where data isn't available yet, we say so plainly instead of rounding up.

What we are not yet, and how you'll know when we are.

  • Open Aya OS is not AGI and does not claim to be. ARC-AGI alignment refers to architecture (multi-strategy reasoning, verifier loops, cost-per-task accounting) — not to a published score.
  • The strategy auction is currently implemented as deterministic system-prompt routing rules, not as six independent learned policies. The /eval harness measures the lift this routing actually provides over a Claude Sonnet 4.6 baseline running the same conversation tier without the cognitive spine — so the A/B delta isolates the wrapping, not a model upgrade.
  • “Self-improving” refers to per-user memory consolidation (Auto-Dream) and TinyAdapter parameter drift, not to weight updates of the underlying base model.
  • Pass rates on /receipts are computed from real, persisted eval runs. If a tier shows “no data”, no run of that tier has completed yet.

Demo · Multi-agent routing

Same prompt. Three routes. See the lift.

The hardest question in any wrapper-over-LLM product is does the wrapping actually help? This demo answers it the only honest way: by running the same task through the raw baseline and through Aya's pipeline, and showing the receipts side by side.

For each card below, set the route selector at the top to match the card's caption, then click Run. The receipt at the bottom of each card shows agents_used, latency_ms, cost_estimate, and confidence.

RouteRoute:

Step 1

Baseline route — Claude Sonnet 4.6 (control)

Expected behaviour: agents_used should be ['executor'] only. No planner, no verifier. Useful as the control.

seed: plan.recipe.1

Step 2

Aya pipeline — anthropic/claude-sonnet-4.6 + 7-stage cognitive spine

Expected behaviour: agents_used should include planner, executor, verifier (and possibly memory_retriever). Latency higher; confidence and pass-rate should be higher too.

seed: plan.recipe.1

Step 3

Aya reasoner — anthropic/claude-opus-4.6, extended thinking (10k)

Expected behaviour: Includes self_critic. Highest cost, typically highest quality. Use this when accuracy matters more than latency.

seed: plan.recipe.1

What to look for.

  • agents_used should grow from 1 (baseline) to 3 (aya_pipeline) to 4 (aya_reasoner). That's the architecture working.
  • latency_ms should grow with each route — wrapping isn't free. The interesting question is whether the latency cost buys a meaningful confidence/pass-rate gain.
  • cost_estimate follows the same pattern. The aya_reasoner route is roughly 4× the cost of baseline; use it deliberately.
  • confidence should improve with the wrapping. If it doesn't, that's a real signal that the task didn't benefit from the cognitive spine — and the harness will honestly tell you so.