Laya

What is it

Laya is an open-source decision-making AI model that runs entirely offline on Apple Silicon — specifically the M4 chip — via CoreML, clocking 45 decisions per second. Think of it as the open-source counterpart to Jev, a proprietary decision engine that has been gaining traction in the AI agent space. Where Jev is closed, cloud-dependent, and paid, Laya is open, local, and free.

The technical essence: CoreML lets Laya run natively on Mac hardware without GPU clusters or API calls. That means zero latency from network round-trips, zero per-inference cost, and complete data privacy — no decision data ever leaves the machine.

The business significance is bigger than the model itself. Laya represents the "local-first AI" wave hitting decision engines specifically. For indie developers, this is a platform shift: you can build agentic tools that make thousands of decisions per minute with no cloud bill and no vendor lock-in. The Jev ecosystem already has users, workflows, and integrations — Laya gives builders an open door into that demand without paying a proprietary tax. That's the wedge.

Why now

Three forces converged to make Laya possible in late 2026, not earlier. First, Apple's M4 chip shipped with a dramatically upgraded Neural Engine — roughly 38 TOPS — which is the first Apple silicon generation where a decision model can hit 45 decisions/second locally without thermal throttling. On M3, the same workload would have been half the speed and twice the heat.

Second, CoreML's toolchain matured. Converting transformer-style decision models to CoreML used to be a multi-week engineering slog. By mid-2026, the conversion pipeline is largely automated, which is why an open-source project could ship a working model this fast.

Third, the Jev ecosystem hit escape velocity. Jev's proprietary pricing and cloud-only architecture created a vocal cohort of developers asking for an open alternative — the same dynamic that gave us Llama against GPT. The Hacker News and V2EX threads that surfaced Laya are exactly that demand signal.

Policy is a tailwind too. Data residency rules in the EU and stricter enterprise procurement around sending decision data to third-party clouds make offline inference a compliance feature, not just a performance one. Laya arrives at the intersection of faster chips, easier tooling, and regulatory pressure. That's why now.

Market Evidence

The signal is thin but directionally clean. Three independent sources — Hacker News, V2EX, and GitHub — picked up Laya within the same window, with a 100% growth rate and 3 total mentions. The term is tagged with "share," "front_page," "story," and "rising," which tells you it hit front-page visibility on at least one platform rather than dying in a comment thread.

Read this honestly: 3 mentions is not a market. It's a spark. The stage is correctly labeled "nascent," and the trend score of 73/100 reflects real early interest — front-page placement on HN doesn't happen by accident. But the opportunity, market, competition, and demand scores all sit at 0/100, which is the data telling you there is no measurable commercial activity yet.

The pattern here matches how Llama, Ollama, and Whisper all started: a single GitHub repo, a front-page post, then a 6-12 month ramp before commercial products appeared. The 100% growth rate is mathematically meaningless at n=3 — it just means it went from near-zero to slightly-more-than-zero.

My position: this is a real technical signal with unproven commercial demand. The hype is not fleeting — offline AI is a durable trend — but Laya specifically could be a footnote if Jev opens up or a bigger player ships a local decision engine first. Treat it as a 90-day watch item, not a build-now mandate.

Who's Behind It

Laya is an open-source project, so the "whales" are less about a single company and more about the ecosystem it plugs into. The primary driver is the Jev ecosystem — Jev is the proprietary decision engine whose users and workflows Laya explicitly targets as the open alternative. Whoever maintains Jev is the incumbent Laya is flanking.

On the platform side, Apple is the silent whale. Every Laya deployment depends on CoreML and Apple Silicon, which means Apple's chip roadmap and CoreML licensing terms directly shape Laya's ceiling. Apple has every incentive to promote local AI — it sells the hardware — but no incentive to fund a specific open-source decision model.

The community layer is Hacker News and V2EX, which is where the early adopters congregate. These are developer-heavy, Apple-heavy, privacy-conscious audiences — exactly the profile that adopts local-first tools first.

The competitive dynamic to watch: if Jev responds by open-sourcing a lite version, Laya's differentiation evaporates overnight. If Jev doubles down on cloud, Laya's niche hardens. Right now nobody has made that move, which is why the window exists.

TAM & Market Size

The addressable market splits into three buyer segments. First, indie developers and small AI teams building agentic tools — they want cheap inference and no vendor lock-in. There are roughly 2-4 million developers worldwide who touch AI agent frameworks, and maybe 10-15% own Apple Silicon Macs suitable for Laya. That's 200,000-600,000 potential users.

Second, privacy-sensitive enterprises — legal, healthcare, finance — that cannot send decision data to a cloud. This segment pays real money. A single mid-size law firm might spend $5,000-20,000/year on local AI tooling to satisfy compliance. There are tens of thousands of such firms.

Third, researchers and hobbyists, who mostly won't pay but drive adoption and word-of-mouth.

Price tolerance: developers will pay $10-30/month for a tool that saves them cloud API costs. Enterprises will pay $200-2,000/month per seat for compliance-grade local inference. The demand score of 0/100 and opportunity score of 0/100 mean none of this is proven yet — you'd be building ahead of the revenue curve.

My read: the developer segment is real but cheap; the enterprise segment is lucrative but slow to sell into. Budget 6-9 months before meaningful enterprise revenue.

Competitive Landscape

The direct competitor is Jev — proprietary, cloud-based, and already embedded in workflows. Jev's strengths: mature integrations, polished UX, and a paying user base. Its weakness is exactly Laya's opening: cloud dependency, per-call pricing, and data leaving the machine.

Adjacent competitors matter more. Ollama dominates local model running but isn't decision-specialized. LM Studio targets the same Apple Silicon audience with a GUI. Apple's own on-device frameworks are a platform risk — if Apple ships a first-party decision API, Laya becomes redundant.

On the open-source side, there's no clear leader in local decision engines yet. That's the gap.

Competition score of 0/100 is misleading — it means no measured competition in this exact niche, not that the space is safe. The real threat timeline: if this niche shows revenue, expect a well-funded player (or Jev itself) to ship a local mode within 6-12 months. Big Tech entry is the existential risk; Apple could bundle it for free.

Differentiation opportunity: don't compete on raw model quality. Compete on integration — the tooling layer that makes Laya usable in real workflows (logging, replay, A/B testing, audit trails). That's where defensibility lives.

Business Model

Recommended model: open-core freemium with a usage-based enterprise tier. The model itself stays free and open — that's the distribution engine. Monetize the operational layer around it.

Pricing:

• Free: Laya model, CLI, basic logging. Drives adoption.
• Pro ($19/month per developer): hosted dashboard, decision replay, A/B testing, team sharing, audit logs. This is the sweet spot — under the $20 psychological threshold, and cheaper than one hour of cloud inference at scale.
• Enterprise ($499-1,999/month per org): SSO, compliance exports, SLA, on-prem deployment support, priority model updates.

Why this fits: developers adopt free tools fast, and the pain point (debugging and auditing decisions) grows with usage. You're not charging for the model — you're charging for the operational scaffolding enterprises need.

12-month forecast:

• Conservative: 500 free users, 25 Pro ($475 MRR), 0 enterprise = ~$5.7K ARR.
• Base: 2,500 free, 150 Pro ($2,850 MRR), 3 enterprise ($1,500 MRR) = ~$52K ARR.
• Optimistic: 10,000 free, 600 Pro ($11,400 MRR), 15 enterprise ($15,000 MRR) = ~$316K ARR.

CAC estimate: $30-60 for Pro (content + community led), payback in 2-3 months. Enterprise CAC $2,000-5,000, payback 6-12 months. Keep the free tier generous — it's your funnel.

MVP Blueprint

A 5-day MVP that proves the core loop: run Laya locally, capture decisions, make them debuggable. Cut everything else.

Day 1-2 — Core CLI wrapper: A Node or Python CLI that wraps Laya's CoreML model, accepts input, returns decisions at the documented 45/sec, and logs every decision to a local SQLite file with timestamp, input hash, and output. Ship this first.

Day 3 — Replay engine: A command that takes a logged decision ID and re-runs it, showing input/output side by side. This is the killer feature — nobody else makes local decisions debuggable.

Day 4 — Minimal web dashboard: Next.js + Tailwind, reads the SQLite log, shows a table of recent decisions with filters. No auth yet, runs on localhost.

Day 5 — Export + polish: JSON/CSV export for audit trails, plus a README that gets a developer from git clone to first decision in under 5 minutes.

Tech stack: Python (pyobjc + CoreML) or Swift for the model wrapper; SQLite for storage; Next.js for the dashboard; ship via GitHub + Homebrew tap.

Cut: cloud sync, multi-user, auth, billing, model fine-tuning. Those are month-2 features.

Fastest path to launch: publish to GitHub, post the replay demo to HN, and let the Jev community find it. The MVP's job is to convert curiosity into a starred repo and a waitlist.

Commercial Opportunities

1. Local decision observability platform. A SaaS that ingests Laya decision logs from developer machines (opt-in) and provides team-wide dashboards, anomaly alerts, and audit exports. Target: AI teams of 3-20 developers at startups. Expected revenue: $3,000-15,000 MRR at 100-500 paying seats. This beats alternatives because it's the operational layer nobody owns yet — Jev keeps decisions in its cloud, so it can't offer true local observability.

2. Compliance-grade offline inference appliance. A packaged Mac Mini (or software bundle) pre-configured with Laya, audit logging, and compliance exports, sold to law firms, clinics, and finance teams. Target: 10-200 person regulated firms. Expected revenue: $1,500-8,000/month across 5-20 customers. This beats generic local-AI tools because it speaks the compliance buyer's language — data never leaves the building.

3. Laya-powered agent API for developers. A managed API that wraps Laya for teams that want local-speed decisions but don't want to manage CoreML themselves — you run the hardware, they call the endpoint. Target: indie devs and small SaaS. Expected revenue: $2,000-10,000 MRR on usage pricing. This beats raw Laya because it removes the Apple-Silicon-only constraint.

Product Ideas

🥇 LayaScope — Decision debugging dashboard. One-line value prop: "See, replay, and audit every decision your local AI makes." Target user: AI developers running Laya or Jev in production. Why now: local decision models just became fast enough to run at scale, but zero tooling exists to debug them. This is the highest-leverage, lowest-competition play, and it monetizes cleanly at $19/month.

🥈 LayaCloud — Managed local-inference API. One-line value prop: "Laya-speed decisions without the Mac Mini." Target user: developers on Linux/Windows or without Apple Silicon. Why now: Laya's CoreML dependency locks out most of the market; a managed bridge captures that demand. Price at $0.001/decision with a free tier.

🥉 LayaAudit — Compliance export tool. One-line value prop: "Prove your AI decisions never left the building." Target user: compliance officers at regulated firms. Why now: EU and enterprise data-residency rules make offline inference a checkbox, and nobody sells the paperwork. Price at $499/month per org.

Priority logic: LayaScope is fastest to build and monetize. LayaCloud expands TAM but needs infrastructure. LayaAudit has the highest ACV but the longest sales cycle. Build in that order.

SEO Opportunity

Search volume for "Laya AI," "local decision engine," and "CoreML decision model" is near zero today — SEO difficulty 0/100 — which means low competition but also low demand. That's an early-mover advantage if the category grows.

Target long-tail keywords: "run AI decisions offline Mac," "Jev open source alternative," "CoreML decision engine tutorial," "local AI agent without cloud," "M4 AI inference speed." These have tiny volume now but will compound as the category matures.

Content strategy: own the tutorial layer. Publish "How to run Laya on your M4 in 5 minutes" and "Laya vs Jev: local vs cloud decisions." Tutorials rank fast in empty categories and capture the exact developers who become customers. Ship one deep guide per week for 8 weeks.

Risk Assessment

Risk 1 — Jev opens up. If Jev ships an open-source or free local tier, Laya's entire pitch collapses. This is the single biggest threat and could happen within 6 months. Validate by watching Jev's changelog and GitHub activity weekly.

Risk 2 — Apple absorbs the category. Apple could ship a first-party on-device decision API, making Laya redundant. Lower probability near-term, but catastrophic if it happens. Hedge by building the tooling layer (LayaScope) that survives regardless of which model wins.

Risk 3 — Demand never materializes. Three mentions and a 0/100 demand score mean the "Jev users want open" thesis is unproven. If the GitHub repo stalls under 500 stars in 60 days, the demand isn't there.

Cheap validation: ship the 5-day MVP, post to HN and the Jev community, and measure waitlist signups. Target: 100 signups in 2 weeks. If you get fewer than 25, walk away. If you clear 100, build LayaScope. Don't write a line of billing code until you have 50 people asking for it.

Action Plan

Today: Clone the Laya repo, run it on your Mac, and time a real decision workload. Confirm the 45/sec claim yourself — if it's marketing fluff, the whole thesis weakens.

Week 1: Build the 5-day MVP (CLI wrapper + replay + localhost dashboard). Post the replay demo to Hacker News and the Jev community with the headline "Open-source local decision debugging for Laya." Collect emails via a simple waitlist page.

Month 1: If you clear 100 waitlist signups, ship LayaScope's hosted tier at $19/month and onboard the first 10 paying users manually. If you clear 25 but not 100, keep building in public and re-test. If under 25, stop.

Month 3: With 50+ paying seats, add team features and start enterprise conversations (LayaAudit). Target $3,000 MRR. If MRR is under $500 at month 3, reassess whether the niche is too small.

The gate is simple: waitlist signups at week 2 and MRR at month 3. Hit them, double down. Miss them, walk.

Related Terms

Local-first AI — the broader movement Laya belongs to; tools like Ollama and LM Studio proved developers want offline inference. Laya applies it to decision engines specifically.

Jev — the proprietary incumbent Laya positions against. Jev's roadmap is the single biggest variable in Laya's future.

CoreML / Apple Silicon AI — the platform layer enabling Laya. As M-series chips improve, every local-AI thesis gets stronger, and Laya rides that curve.

These three trends reinforce each other: better chips enable local models, local models need open alternatives to proprietary engines, and open alternatives need tooling — which is the business opportunity.