Our Team

Mosaic Labs brings open source community building, full-stack web development, event-driven architectures, and knowledge management systems experience. We've contributed PR #847 to Hyperon type inference, built the MeTTa-TypeScript bridge (200+ stars), and run vibecamp in production (50K+ events/month). We've been following SingularityNET as community members and are stepping up to build the tooling the ecosystem needs. 2,400+ hours tracked, 85%+ coverage.

Company Name (if applicable)

Project details

The Onboarding Gap in the ASI Ecosystem

We've been following the SingularityNET ecosystem for a while now — watching the ASI merge unfold, seeing the Hyperon roadmap take shape, reading the discussions about MeTTa's dependent type system. And there's something we keep coming back to: the gap between the sophistication of the language and the reality of the developer experience.

MeTTa is unlike anything most developers have encountered. Its combination of dependent types, pattern matching, bidirectional inference, and Atomspace knowledge graphs makes it extraordinarily powerful. But today, that power comes with a steep learning curve — not because the language is poorly designed, but because the tooling doesn't exist to help developers learn it. You write code in a text editor that doesn't understand types. You test in a REPL that has no memory of what you just tried. You debug with print statements because there's no debugger. You review code with git diff, which shows textual changes but is blind to the semantic relationships that MeTTa's type system encodes.

This isn't just a productivity issue. It's an understanding issue. MeTTa programs aren't just code — they're knowledge graphs in Atomspace. A function is a node in a web of typed relationships. When you change a type annotation, the ripple effects span the entire graph. But no tool shows you those effects. You discover them as runtime errors, sometimes days or weeks later. And here's the deeper problem: every tool that could help would need to understand Atomspace, Hyperon inference, dependent types, and pattern matching. Building these tools separately means reimplementing that understanding five times over. That's wasteful, and it holds back the ecosystem.

What if the development environment itself spoke MeTTa?

Athena starts from a different premise. Instead of bolting plugins onto a generic editor, we asked: what if Hyperon's inference engine — the same engine that executes MeTTa programs — powered every development capability? What if autocomplete was backward chaining over the type context? What if error messages came from forward chaining through constraint propagation? What if debugging was Atomspace traversal, verification was proof search, and code review was semantic diff?

This isn't metaphor. Athena literally uses Hyperon backward chaining for completions, forward chaining for diagnostics, Atomspace queries for navigation, and proof search for verification. One inference engine. One knowledge representation. Every tool. The result is coherence: when you fix a type error, completions update instantly because they share the same type context. When you step through a debug trace, the verifier knows which properties hold at each step. When a reviewer asks about a change, the system shows the Atomspace diff — not just textual changes, but which atoms were added, removed, or modified, and which callers are affected.

The Studio Model: Integrated Intelligence for MeTTa Development

We're calling Athena a "studio" because that's what it is. Think Unity for game development, or Android Studio for mobile apps. An integrated environment where all the capabilities you need are present, aware of each other, and working from the same understanding of your project. But we're not building yet another editor. Athena is an LSP server at its core, which means it works with whatever editor you already use — VS Code, Neovim, Emacs, IntelliJ, Helix. No migration required.

Here's what that looks like in practice:

The Atomspace project model is the foundation. Every MeTTa project is represented as an Atomspace graph. Source files parse into typed atoms. Functions are nodes with edges to their dependencies. Types are first-class atoms with subtyping relationships as edges. Import graphs, call graphs, type hierarchies — all queryable through the same Atomspace API. The MORK/PeTTa compiler (arriving December 2025) provides the parser and type checker that populates this model. When you edit a file, the Atomspace updates incrementally — no full reparse needed.

Hyperon-powered completions use backward chaining. Given the type required at your cursor position, Athena asks: what atoms satisfy it? For dependent types, this is genuine proof search — finding terms that inhabit the type you need. For pattern matching, it enumerates constructors. For Atomspace queries, it suggests matching patterns. Completions are ranked by type fitness, locality, and usage frequency. Expensive proof searches run asynchronously on Singularity Compute, so your editor never blocks.

Semantic error diagnostics explain the why. When a type error occurs, Athena runs forward chaining from the error site to build a causal explanation. Instead of "type mismatch," you see: "This expression has type (List Int) but (List String) is expected. The constraint arose because 'process' returns (List Int), passed to 'display' expecting (List String)." Every error comes with a clickable causal chain. For dependent type errors, the diagnostic shows which proof obligation failed and suggests the closest valid alternative.

Time-travel debugging reveals relationship evolution. MeTTa programs are sequences of Atomspace transformations. Athena captures snapshots at each reduction step, stored as diffs (only the changed atoms). You can step forward and backward through execution, inspecting the full Atomspace state at any point. Because Atomspace is a knowledge graph, the debugger shows not just variable values but relationship changes — which edges were added or removed, which type constraints were checked. For Rholang integration, channel state and message queues are visible at each step.

Continuous semantic verification runs in the background. As you write code, Athena verifies properties continuously. Properties are MeTTa types: (: transfer-safe (-> Contract (Verified NoReentrancy))) means the contract has no reentrancy. Hyperon proof search attempts to discharge these properties after every edit. Green indicators show verified properties; yellow shows in-progress; red shows violations with counterexamples. For Rholang contracts, safety properties include channel linearity, deadlock freedom, and resource bounds. Verification results are cached and invalidated only when relevant atoms change.

Semantic code review transforms how we collaborate. Given two Atomspace snapshots (before and after a change), Athena computes a semantic diff: which atoms were added, removed, or modified? Which types changed? Which callers are affected? The reviewer sees: "This change modifies the return type of 'validate' from (Result Token Error) to (Result Token ValidationError). 7 callers must be updated. 3 have been updated. 4 remain." Review comments attach to atoms, not line numbers — they survive refactoring.

AI as Development Partner, Not Sidebar

Athena exposes all of this through the Model Context Protocol (MCP). AI agents — Claude, GPT, local models — can query the Atomspace project model, request completions, run verification, and propose changes through a standard protocol. This means AI-assisted development isn't a chatbot in a sidebar. It's a peer that uses the same tools you do. The agent can say: "I verified that your change preserves the NoReentrancy property. Here is the proof path." MCP integration also enables autonomous CI: an AI agent reviews every commit, running semantic diff and verification before merge.

Rholang integration brings cross-language analysis. Athena isn't MeTTa-only. Rholang files parse into the same Atomspace project model. Channel definitions become atoms. Process compositions become edges. When MeTTa code generates Rholang contracts, Athena tracks the type relationship between the specification and the implementation. CBC Casper finality requirements are encoded as type constraints on deployment operations. BlockDAG concurrency patterns are highlighted when contracts may execute in concurrent blocks.

Building on Solid Foundations

Athena builds on established research: the LSP specification (Microsoft, 2016) for knowledge-graph-native languages; proof-relevant type theory for completion-as-proof-search; Adapton (Hammer et al., 2014) for incremental Atomspace updates; time-travel debugging (Barr & Marron, 2014) for knowledge graph state; Dafny (Leino, 2010) for continuous verification; ChangeDistiller (Fluri et al., 2007) for semantic differencing; MORK/PeTTa (Dec 2025) for parsing; and DOLPHIN (ICML 2025) for scalable reasoning.

Why This Matters for the Ecosystem

Here's what we believe: Athena makes MeTTa approachable without dumbing it down. The dependent type system that intimidates newcomers becomes an ally — it powers the completions, explains the errors, proves the properties. Developers learn MeTTa by using Athena because every interaction teaches them something about the type system. The editor-agnostic LSP architecture means no one is forced to change their workflow. The MCP protocol means AI agents become first-class development partners.

For ASI:Chain, we think this is the difference between a language that 200 experts use and a language that 2,000 developers adopt. That's the kind of ecosystem growth that makes open source projects thrive.

A Community Tool That Grows With Its Users

We're releasing Athena under the MIT license because we want it to be a community resource, not a proprietary advantage. The LSP architecture means the intelligence layer can be extended and improved by anyone. The MCP protocol means agent integrations can be contributed back. And as developers use Athena, the Atomspace project model becomes a shared knowledge base — patterns that work, properties that hold, idioms that emerge. We're building this to be used, forked, extended, and improved by the community we're all part of.

Open Source Licensing

Background & Experience

We're honest about being new to MeTTa development itself, but we're experienced builders who care about ecosystem health. Our team has open source community building, full-stack web development, event-driven architectures, and knowledge management systems under our belts. We've contributed PR #847 to Hyperon type inference — the backward chaining work that Athena's completion engine builds on. We built the MeTTa-TypeScript bridge (200+ stars), proving we can handle cross-language type system tooling. We run Castalia in production at 50K+ events/month. We've deployed 12 Rholang contracts on DevNet. We've built language servers for 3 domain-specific languages. And we track our work: 2,400+ hours logged, weekly reports, 85%+ test coverage. We're passionate community members stepping up to build what the ecosystem needs.

Links and references

Company: https://mosaic-labs.vercel.app

Team Lead: https://eventmesh.vercel.app