DEEP Connects Bold Ideas to Real World Change and build a better future together.

DEEP Connects Bold Ideas to Real World Change and build a better future together.

Coming Soon

GroundUp: Production Dev Toolkit for ASI:Chain

chevron-icon
RFP Proposals
Top
chevron-icon
project-presentation-img
user-profile-img
Jenniferoka
Project Owner

GroundUp: Production Dev Toolkit for ASI:Chain

Expert Rating

n/a

Overview

You've just written your first MeTTa contract. Now what? GroundUp gives ASI:Chain developers the professional tools they deserve: LSP-powered diagnostics in any editor (VS Code, Neovim, you name it), one-command DevNet deployment with real-time BlockDAG monitoring, an AI assistant that actually understands Rholang concurrency patterns and runs on Singularity Compute, plus a zero-install web playground. We're not reinventing development — we're bringing the proven patterns from TypeScript, Rust, and Ethereum tooling to ASI:Chain. No moonshots, just tools that work on day one.

RFP Guidelines

Open for Proposals

An AI-native Development Environment for...

Ending on:

13 Feb. 2026

Days
Hours
Minutes
  • Type SingularityNET RFP
  • Total RFP Funding $50,000 USD
  • Proposals 21
  • Awarded Projects n/a

An AI-native Development Environment for the ASI:Chain

Proposal Submission (1 days left)
  • Type SingularityNET RFP
  • Total RFP Funding $50,000 USD
  • Proposals 21
  • Awarded Projects n/a
author-img
SingularityNET
Feb. 4, 2026

This RFP seeks proposals for the development of an AI-native Development Environment (IDE) that improves the efficiency and accessibility of blockchain application development for the ASI:Chain.

Proposal Description

Our Team

We're a small dev tools team that cares deeply about developer experience. We've shipped LSP servers, deployment CLIs, and web-based coding environments for blockchain platforms (Polygon, Avalanche) and internal DSLs. We discovered ASI:Chain through DEEP Funding and got hooked by the vision. We're learning Rholang and MeTTa with fresh eyes, which helps us see exactly where the tooling gaps hurt most.

Company Name (if applicable)

Bedrock Software

Project details

## You've Just Written a MeTTa Contract. Now What?

 

Picture this: you've spent the afternoon learning Rholang's concurrent process algebra. You've written your first smart contract. It compiles. You're ready to deploy to DevNet and see it run.

 

Except... there's no deploy button. No transaction monitor. No way to see if your contract is even on the BlockDAG. You copy-paste commands from a forum post, manually sign the transaction, pray you got the phlogiston estimate right, and wait. Did it work? You're reading raw logs to find out.

 

This is the ASI:Chain developer experience today. And we've been there.

 

## The Developer Experience Gap

 

We came to ASI:Chain through the DEEP Funding program, drawn by the vision of neural-symbolic AI meeting blockchain through Rholang, MeTTa, and Atomspace. The technology stack is genuinely exciting — concurrent process algebra for contracts, neural-symbolic reasoning, BlockDAG consensus, decentralized compute via Singularity Compute.

 

But when we tried to build something? The tooling just isn't there.

 

You write Rholang in a plain text editor. No syntax highlighting. No real-time error checking. No autocompletion suggesting channel names or catching concurrency bugs before you deploy. MeTTa has the same problem. Want to deploy? You're writing bash scripts. Want to monitor transactions on the BlockDAG? Hope you like reading JSON logs. Want to debug a race condition? Good luck.

 

This isn't a minor inconvenience. Professional developers evaluating ASI:Chain take one look at the tooling situation and go back to ecosystems where `npm install` and VS Code just work. The few developers who stick around spend half their time fighting the tools instead of building applications.

 

We think ASI:Chain deserves better. And honestly, we wanted better for ourselves.

 

## What GroundUp Delivers: Your Developer Journey, Start to Finish

 

GroundUp is built around the actual developer workflow — the path from "I have an idea" to "it's running on DevNet." We're not building a revolutionary new IDE or inventing novel paradigms. We're bringing the proven patterns from TypeScript, Rust, and Ethereum tooling to ASI:Chain. Here's how it works.

 

### Getting Your First Contract Written (LSP for Rholang & MeTTa)

 

You open VS Code. You start typing Rholang. As you type, you get:

 

- Real-time error checking that catches syntax mistakes immediately, not after you try to compile

- Intelligent autocompletion that suggests channel names, process patterns, and concurrent composition templates

- Hover documentation explaining what each process does

- Go-to-definition that jumps you to where a process or channel is defined

- Type inference that surfaces concurrency errors — race conditions, deadlocks, channel misuse — before you deploy

 

This is the Language Server Protocol (LSP), the same technology that powers TypeScript, Rust, Python, and 50+ other languages. We're implementing it for Rholang and MeTTa so you get this experience in any editor — VS Code, Neovim, Emacs, Sublime, whatever you use.

 

For Rholang, the LSP understands process algebra. It tracks how names flow through concurrent processes. It suggests completions based on the channels you've already defined. It warns you when you're about to create a deadlock.

 

For MeTTa, the LSP understands Atomspace. It type-checks against MeTTa's dependent type system. It resolves grounded atoms to their implementations. It shows you which atoms a pattern will match. And if you're running a local Atomspace instance, it connects to it for live knowledge base exploration.

 

The best part? Both LSPs share a diagnostic framework. When a MeTTa program generates Rholang code, the LSP validates both sides of the boundary in real time. No more "it compiled but failed at runtime" surprises.

 

### Getting Your Contract Verified (Error Messages That Actually Help)

 

When something's wrong with your code, you shouldn't need a PhD to understand the error message.

 

GroundUp's LSP diagnostics are written for humans. Instead of "parse error at line 47," you get "This process is waiting on channel 'response' but no other process sends to it — potential deadlock." The error points you to the exact line. It explains what's wrong. And the AI assistant (more on that below) can suggest a fix.

 

We've learned from building dev tools for other ecosystems: good error messages are the difference between a developer who gets unstuck in 2 minutes and a developer who gives up and goes to Discord for help.

 

### Getting Your Contract Deployed (One Command, Full Visibility)

 

You've written your contract. It type-checks. You're ready to deploy to DevNet. You type:

 

```bash

groundup deploy contract.rho --network devnet

```

 

One command. GroundUp compiles your contract, signs the transaction, submits it to DevNet, and tracks confirmation. You see:

 

- Real-time BlockDAG visualization showing where your transaction is in the DAG

- Which validators have seen it

- CBC Casper finality status progressing from "pending" to "finalized"

- Phlogiston costs (estimated before deployment, actual after)

- A deployment receipt with contract hash, transaction ID, and timestamp

 

All of this is logged to a deployment history, so you can look back at every contract you've shipped. And if you're deploying multiple interdependent contracts? GroundUp analyzes channel references and deploys them in the correct order automatically.

 

We also built this as a VS Code panel, so you can deploy interactively without leaving your editor. But the CLI interface means you can also drop it into CI/CD pipelines for automated deployments.

 

### Getting Help When You're Stuck (AI That Understands Rholang)

 

You're staring at a concurrency bug. You know something's wrong, but you're not sure what. You select the problematic Rholang code and ask the AI assistant: "What's wrong here?"

 

The assistant explains, in plain English: "This process sends on channel X and then immediately waits on X. Since Rholang processes run concurrently, there's a race condition — the send might not complete before the wait, causing a deadlock."

 

It suggests a fix. You click "Apply." The code updates with correct Rholang syntax.

 

GroundUp's AI assistant isn't a general-purpose chatbot. It's a specialized coding assistant trained on Rholang process algebra patterns and MeTTa Atomspace idioms. It draws from a curated library of 50+ verified patterns — token contracts, governance mechanisms, oracle integrations, multi-party computation protocols, AI agent templates.

 

You can describe what you want in natural language, and it generates code that uses correct concurrent patterns and channel management. You can paste any Rholang process and get an explanation of its behavior, including potential race conditions and deadlocks. And when the LSP reports an error, the assistant explains why and suggests syntactically correct fixes.

 

Oh, and it runs on Singularity Compute. We're keeping AI capabilities decentralized, within the ASI:Chain ecosystem, rather than hitting OpenAI's API. It's both philosophically aligned with decentralization and a practical demonstration that Singularity Compute works for real developer workloads.

 

### Getting Started (Zero-Install Playground)

 

Before you install anything, you want to try ASI:Chain and see if it clicks. You open the GroundUp playground in your browser.

 

You get:

- Browser-based Rholang and MeTTa editors with the same LSP diagnostics as the desktop experience

- Instant execution against a sandboxed DevNet environment

- Shareable URLs — send someone a link and they see exactly what you're working on

- Step-by-step tutorials covering common patterns: token creation, governance voting, oracle integration, AI agent deployment

- Pre-loaded examples you can edit and run immediately

 

No install. No command line. Just open a browser and start coding. It's how Remix (Ethereum), Rust Playground, and Go Playground work. We're bringing that experience to ASI:Chain.

 

The playground is built as a static web app with a lightweight backend proxy to DevNet, so it's cheap to host and scales easily. We're not running heavy infrastructure — just giving developers a frictionless onboarding path.

 

## Developer Experience Principles We Live By

 

We've built LSP implementations, CLI tools, and web playgrounds for other ecosystems (Polygon, Avalanche, and some internal domain-specific languages). Here's what we've learned:

 

**Error messages should explain the problem, not just report it.** "Potential deadlock: process waits on channel with no sender" beats "type error at line 23."

 

**Onboarding should happen in the browser.** If a developer has to install tools before trying your platform, half of them won't try it.

 

**One command should do the whole thing.** Developers shouldn't manually compile, sign, and submit. `groundup deploy` does all three.

 

**Tools should meet developers where they are.** That's why we're doing LSP (works in any editor) rather than building a custom IDE that only works in one place.

 

**Documentation should be interactive.** Static docs are fine, but a tutorial you can run in the playground is better.

 

GroundUp is designed around these principles. Every component asks: "How do we make this easier for the developer?"

 

## Why We're Using Proven Patterns, Not Inventing New Ones

 

We're not building novel architecture. We're implementing known-good solutions for a new language ecosystem.

Open Source Licensing

MIT - Massachusetts Institute of Technology License

Background & Experience

We've built developer tooling for the past 5 years — two LSP servers (both in production with 300+ devs using them daily), deployment CLIs for Polygon and Avalanche smart contracts, a web playground that onboarded 500+ developers in its first quarter, and contributions to Hardhat and Foundry. We came to ASI:Chain as outsiders through the DEEP Funding program, got fascinated by the Rholang/MeTTa/Atomspace vision, and immediately hit the tooling wall. That's what sparked GroundUp: we wanted the tools we're used to having, and we know how to build them. Our specialty is making complex tech accessible through good UX — helpful error messages, smooth onboarding, docs that don't assume you have a PhD. We ship on time and on budget because we use proven patterns, not moonshots.

Links and references

OpenCog Wiki (Atomspace): https://wiki.opencog.org/

Company: https://bedrock-software.vercel.app

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

Proposal Video

Not Avaliable Yet

Check back later during the Feedback & Selection period for the RFP that is proposal is applied to.

  • Total Milestones

    3

  • Total Budget

    $44,000 USD

  • Last Updated

    13 Feb 2026

Milestone 1 - LSP for Rholang & MeTTa + DevNet Deploy CLI

Description

Build the two core infrastructure components that every ASI:Chain developer needs immediately. The Rholang LSP provides real-time syntax parsing with error recovery, process algebra-aware autocompletion, channel name tracking, and basic type inference for concurrent patterns. The MeTTa LSP provides atom expression parsing, dependent type checking, grounded atom resolution, and pattern match analysis against local Atomspace instances. Both LSPs share a common diagnostic bridge that catches errors at the Rholang-MeTTa boundary. The DevNet deployment CLI provides one-command contract deployment with automatic compilation, signing, submission, and BlockDAG confirmation tracking. It includes deployment history logging, multi-contract dependency resolution based on channel references, and phlogiston cost estimation. Both LSPs are tested against 30+ code samples covering common patterns and known edge cases in each language.

Deliverables

1. Rholang LSP: syntax parsing with error recovery, autocompletion for processes/channels/contracts, name binding analysis, go-to-definition, symbol search, and hover documentation — packaged as VS Code extension with extension marketplace listing 2. MeTTa LSP: atom expression parsing, dependent type checking, grounded atom resolution, pattern match preview, and Atomspace connection for live knowledge exploration — packaged as VS Code extension 3. Cross-language diagnostic bridge catching MeTTa-Rholang interop errors at the type and channel boundary 4. DevNet deployment CLI: compile, sign, deploy, track confirmation, and log deployment history in one command 5. BlockDAG transaction tracker showing real-time DAG position, validator propagation, and CBC Casper finality status 6. Multi-contract orchestration with automatic dependency resolution based on channel reference analysis 7. Phlogiston cost estimator providing pre-deployment cost analysis based on contract complexity 8. 30+ test cases per LSP covering common patterns, edge cases, and error recovery scenarios 9. All code published on GitHub under MIT license with CI/CD pipeline and contributor guide

Budget

$9,000 USD

Success Criterion

1. Rholang LSP provides real-time error diagnostics with <500ms latency in VS Code for files up to 1000 lines, including error recovery on incomplete code 2. MeTTa LSP correctly type-checks 90%+ of Hyperon example programs without false positives, with Atomspace connection for grounded type resolution 3. Cross-language diagnostic bridge detects 5 known MeTTa-Rholang interop error patterns including type mismatches and channel naming inconsistencies 4. DevNet CLI successfully deploys and confirms 10 different contract types on DevNet with deployment receipts logged 5. BlockDAG tracker accurately shows transaction DAG position and CBC Casper finality progress in real time 6. Multi-contract deployment correctly resolves dependency ordering for 3-contract test systems with automatic channel analysis 7. All test suites pass with >90% coverage on core parsing, type checking, and deployment logic 8. External developer (not on team) installs and uses both LSPs without assistance within 15 minutes

Milestone 2 - AI Assistant on Singularity Compute + Playground

Description

Build the AI coding assistant that runs on Singularity Compute and understands Rholang process algebra and MeTTa Atomspace patterns. The assistant provides natural language to code generation for both languages, code explanation with concurrency analysis (identifying potential race conditions and deadlocks in Rholang), a curated pattern library of 50+ reusable contract and reasoning templates, contextual error diagnosis integrated with LSP diagnostics, and MeTTa reasoning template generation for common AI agent patterns. The assistant runs on Singularity Compute, demonstrating the platform's utility for AI workloads within the ASI:Chain ecosystem. Simultaneously, build the web playground: a browser-based environment with the same LSP diagnostics, connected to a sandboxed DevNet for instant execution, shareable URLs for examples and bug reports, and pre-loaded tutorials covering token creation, governance, oracle integration, and AI agent deployment. The playground is a static web application with minimal backend, ensuring low hosting costs and high scalability.

Deliverables

1. AI coding assistant with Rholang code generation from natural language descriptions, producing process-algebra-correct concurrent code 2. AI coding assistant with MeTTa reasoning template generation for common agent patterns including perception, inference, and learning loops 3. Code explanation engine analyzing concurrent behavior, identifying race conditions, deadlocks, and channel misuse with plain-language descriptions 4. Curated pattern library: 50+ verified Rholang and MeTTa patterns covering tokens, governance, oracles, agents, and multi-party computation 5. LSP-integrated error diagnosis: AI explains errors in context and suggests syntactically correct fixes with one-click application 6. Singularity Compute integration: all assistant inference runs on decentralized compute with fallback to local inference if unavailable 7. Web playground with browser-based Rholang and MeTTa editors using full LSP diagnostics including autocompletion and error highlighting 8. Sandbox DevNet connection for instant in-browser contract execution with transaction result display 9. Shareable playground URLs with state persistence, and 5 pre-loaded interactive tutorial walkthroughs

Budget

$30,000 USD

Success Criterion

1. AI generates compilable Rholang for 8 out of 10 natural language contract descriptions, with correct process algebra patterns 2. AI generates valid MeTTa reasoning templates for 5 common agent patterns that type-check against Atomspace 3. Code explanation correctly identifies concurrency issues (races, deadlocks, channel misuse) in 4 of 5 test Rholang programs 4. Pattern library covers the 10 most-requested contract types identified through ASI:Chain community survey and forum analysis 5. Error diagnosis provides actionable, syntactically correct fix suggestions for 80%+ of common LSP-reported errors 6. Singularity Compute integration processes AI requests with <10 second average response time, with graceful local fallback 7. Web playground loads in <3 seconds and successfully executes contracts against sandbox DevNet with visible results 8. Shareable URLs correctly reproduce full code state and editor configuration for 100% of shared playground sessions 9. 3 external developers complete a full tutorial walkthrough without assistance and rate usability 4+/5

Milestone 3 - Integration Polish, Testing & Ecosystem Launch

Description

Integrate all four components into a cohesive toolkit, conduct thorough cross-component testing, perform user testing with real ASI:Chain developers, and launch to the ecosystem. Integration work includes connecting the AI assistant to the LSP for contextual suggestions within editors, linking the deployment CLI to the playground for one-click DevNet deployment from the browser, and adding the BlockDAG transaction monitor as both a CLI output and a VS Code panel. User testing involves recruiting 5+ ASI:Chain developers to use the complete toolkit for real development tasks, collecting feedback, and iterating on pain points. Documentation covers installation guides, API references, tutorial series, and video walkthroughs. Community launch includes publishing packages to npm/PyPI, announcing on ASI:Chain developer channels, and presenting at a SingularityNET community call. All components are hardened for production use with error handling, graceful degradation, and offline capability for the LSPs.

Deliverables

1. Integrated VS Code experience: LSP diagnostics, AI assistant inline suggestions, and deployment panel working together in a single workspace without conflicts 2. Playground-to-DevNet deployment pipeline enabling one-click browser deployment with real-time transaction confirmation feedback 3. BlockDAG monitor as both VS Code panel and CLI output showing DAG structure, validator propagation, and CBC Casper finality visualization 4. User testing report: structured feedback from 5+ ASI:Chain developers using the full toolkit for real development tasks, with prioritized improvement recommendations 5. Comprehensive documentation: installation guide for all platforms, API reference for all tools, and 3 end-to-end tutorial walkthroughs covering different use cases 6. Video walkthrough: 10-minute narrated demo covering the complete developer workflow from code authoring to DevNet deployment 7. npm/PyPI packages published for all components with semantic versioning and automated release pipeline 8. Production hardening: comprehensive error handling, offline LSP mode for disconnected development, and graceful Singularity Compute fallback 9. Community launch: blog announcement, presentation at SingularityNET community call, and tutorial promotion on developer channels

Budget

$5,000 USD

Success Criterion

1. All four components (LSP, AI assistant, deployment CLI, playground) work together without conflicts in a single VS Code workspace across Windows, macOS, and Linux 2. End-to-end workflow (write Rholang/MeTTa code, get AI help, deploy to DevNet, monitor on BlockDAG) completes in <5 minutes for a standard token contract 3. 5 external developers successfully complete real development tasks using the complete toolkit, including at least one multi-contract deployment 4. User satisfaction score of 4+/5 from testing participants on core workflow usability, with specific feedback on LSP responsiveness and AI helpfulness 5. Documentation enables a new developer to install all components and deploy their first contract to DevNet within 30 minutes 6. All packages published and installable via standard package managers (npm for JS, pip for Python) with dependency resolution 7. Zero critical bugs and fewer than 5 non-critical bugs in the production-hardened release candidate 8. Video demo viewed by 50+ community members within first week, with engagement metrics tracked

Join the Discussion (0)

Expert Ratings

Reviews & Ratings

    No Reviews Avaliable

    Check back later by refreshing the page.

Welcome to our website!

Nice to meet you! If you have any question about our services, feel free to contact us.