Lindqvisk

Project Owner

Tandem: AI Pair Programmer for MeTTa

Expert Rating

n/a

Type SingularityNET RFP
Funding Request $49,000 USD
RFP Guidelines An AI-native Development Environment for the ASI:Chain

Overview

Three features. One tool. Code completions that use Hyperon backward chaining instead of LLM token prediction — every suggestion type-checks because it comes from inference over your Atomspace. Diagnostics that show the full inference chain that produced each error, with fix suggestions computed via backward chaining. Rholang contract generation from MeTTa type specs with cost estimation. Not a full IDE. An LSP server that works in any editor. What developers need for writing MeTTa code: type-correct completions, errors that explain themselves, and contracts that match their types.

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

SingularityNET

Feb. 4, 2026

View RFP

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 build developer tools and ML-powered code analysis systems. Experience in LSP server implementation, Rust systems programming, and research prototyping. Background includes IDE tooling, language server protocols, and code intelligence infrastructure. Track record: 3 grants delivered on-time, 2,400+ hours tracked, 85%+ test coverage across projects.

Company Name (if applicable)

Verdant Labs

Project details

## The Problem

MeTTa has dependent types that encode semantic constraints. Your type system knows that a balance must be positive, that a validated input has passed its schema check, that a non-empty list cannot be empty. But your code completion tool does not. Copilot suggests code based on what patterns look like in training data. It cannot see that (Amount (< balance)) excludes negative values. When it suggests a completion, you get syntax that might compile but semantics that violate your types. The type checker catches it three keystrokes later. This is the wrong order of operations.

## Our Approach

We replace token prediction with inference. Instead of asking what code looks like, we ask what code is valid. The completion engine uses Hyperon backward chaining over your project's Atomspace. When you pause at a function call, the LSP server identifies the expected type at the cursor (including dependent type constraints), runs backward chaining to find all atoms that satisfy those constraints, and returns them as suggestions. Every completion type-checks before you see it.

This is not an LLM wrapper. This is inference-based pair programming.

## Type-Correct Completions

**What it does**: Suggests code based on what your type system allows, not what training data predicts.

**How it works**: Your project becomes an Atomspace. Functions, types, variables — all atoms with typed links. When the LSP server receives a completion request, it determines the expected type at the cursor position (which may be a dependent type like (ValidatedInput schema)), runs Hyperon backward chaining to find atoms matching that type constraint, and returns them as completion suggestions. All suggestions are guaranteed to type-check.

**Why it matters**: In MeTTa, type-correct means semantically meaningful. If a function expects (NonEmpty (List Token)), empty lists do not appear in suggestions. If it expects (Amount (> 0)), negative values are excluded. The filtering happens at the type level, not the syntax level. An LLM cannot do this because it does not have access to your dependent type constraints during generation.

For deep inference chains (4+ steps), we use tiered architecture. Local Hyperon handles shallow inference (<200ms) for immediate suggestions. Singularity Compute handles deep inference in the background, with results streaming in as 'deep suggestions' a moment later. The developer sees fast shallow completions immediately and richer options shortly after.

## Diagnostics with Inference Chains

**What it does**: Shows why an error occurred, not just what the error is.

**How it works**: When Hyperon forward chaining detects a type violation during project analysis, Tandem extracts the full inference chain that led to the error and renders it in natural language. A diagnostic might read: 'This expression returns (Result Error) but the caller on line 42 expects (Result Success). The expectation comes from: validate() on line 38 succeeds (step 1), which constrains processOrder() input to (ValidatedOrder) (step 2), which means the return type must be (Result Success) because ValidatedOrder excludes error cases (step 3). The violation occurs because you handle the unvalidated case without returning early.'

**Why it matters**: Most compilers give you conclusions. Tandem gives you reasoning. The inference chain is not generated by templates — it is the actual logical path Hyperon followed to detect the error. Developers see the type system's logic, which makes fixes obvious. Understanding why an error occurred is the difference between pattern-matching a fix and learning your type system.

Fix suggestions use the same principle. When an error is detected, backward chaining finds the minimal edit (fewest atom changes) that resolves it. The fix is itself type-checked before being suggested. Multiple fix strategies may exist. Tandem ranks them by minimality and shows a diff preview with the inference chain justifying each fix.

## Rholang Contract Generation from Type Specs

**What it does**: Generates Rholang contracts from MeTTa type specifications with inline cost estimates.

**How it works**: A developer writes MeTTa types describing a contract's channels, constraints, and state transitions. Tandem uses Hyperon inference to derive the corresponding Rholang process structure. Channel types in MeTTa map to channel capabilities in Rholang. Dependent types constraining token amounts become Rholang guards. State machine types become process patterns. The generated Rholang appears inline with annotations showing which MeTTa type maps to which Rholang construct. Edit the types, the Rholang updates live.

**Why it matters**: Developers can work at the type level and get correct implementations. This is not template expansion — the Rholang structure is inferred from the types. CBC Casper finality requirements are encoded as type constraints; a contract requiring 2/3 finality gets the appropriate consensus checks generated automatically. BlockDAG concurrent execution paths are visible in the type structure (parallel channels become concurrent processes). Cost estimation runs during generation using path enumeration over the process structure. Annotations appear inline: '// Estimated: 120-180 phlo (best/worst case).' Not a separate tool. Part of the generation loop.

Supported contract patterns: token contracts (ERC-20 equivalent), governance (voting, proposals), escrow (multi-party conditional transfer), marketplace (listings, bids, settlements), staking (delegation, rewards). Each has a well-defined MeTTa type template. Custom patterns compose from these.

## Technical Foundation

The LSP server is the core. It speaks Language Server Protocol, so it works with any editor that implements LSP: VS Code, Neovim, Emacs, Sublime Text, Eclipse, Monaco-based web editors. We ship a VS Code extension for polish, but the server is editor-agnostic.

LSP capabilities implemented:

- textDocument/completion: Hyperon backward chaining for type-correct suggestions

- textDocument/diagnostic: Hyperon forward chaining with inference chain extraction

- textDocument/codeAction: Fix suggestions via backward chaining

- textDocument/hover: Type information with inference context

- textDocument/definition: Atomspace link traversal

- textDocument/references: Atomspace reverse link traversal

- textDocument/rename: Type-safe atom renaming

- Custom: metta/rholangGenerate (type-to-Rholang), metta/inferenceChain (show reasoning)

The server maintains a live Atomspace of the project. File edits update the Atomspace incrementally (only modified atoms re-infer). Full project re-inference runs in the background with results streaming to the editor. MORK/PeTTa (Dec 2025 Rust compiler) provides parsing. Hyperon provides inference.

The developer workflow: Open a MeTTa project in VS Code. Atomspace loads in background. Start typing. Completions appear — all type-correct. Type checker runs. Error appears with full inference chain. Click lightbulb for fix suggestions with diff previews. Accept a fix. Write a type spec for a Rholang contract. Rholang generates inline with cost estimates. Edit types, Rholang updates. Three features. One tool.

Builds on established foundations: LSP (Microsoft, 2016) for editor integration. Hyperon inference (SingularityNET, 2023) for type-directed operations. MORK/PeTTa (Dec 2025) for MeTTa parsing. Rholang (Meredith & Radestock, 2005) for process calculus. CBC Casper (Zamfir, 2018) for consensus-aware constraints. Dependent types (Martin-Lof, 1984) for semantic precision. Singularity Compute for deep inference offloading.

Open Source Licensing

MIT - Massachusetts Institute of Technology License

Background & Experience

Sarah Lindqvist (Technical Lead) has worked in programming language tooling and developer productivity research for eight years. Our team came to MeTTa through academic channels — we saw a symbolic language with rich dependent types but no proper code intelligence tooling. That is a solved problem for mainstream languages (TypeScript, Rust, Python all have excellent LSP servers), but symbolic languages need different approaches. We have built LSP servers, worked with ML-powered code analysis, and done research prototyping of developer tools. We discovered that Hyperon's inference engine could be used for type-directed completions and diagnostics if properly integrated into an LSP architecture. This proposal applies our LSP and editor tooling expertise to a language that needs it.

Links and references

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

https://parselight.vercel.app

Activity Summary

Milestones

4

Total

Discussion

0

Total Comments

Reviews

0

Total Posted

Project Team

3

Total People

Total Milestones
4
Total Budget
$49,000_USD
Last Updated
13 Feb 2026

Milestone 1 - LSP Server Foundation + Atomspace Project Model

Description

Build the LSP server skeleton and establish the Atomspace project model that powers all three features. Implement: LSP server framework (tower-lsp or vscode-languageserver), project initialization (MeTTa files -> Atomspace), incremental file sync (edit -> Atomspace update), and basic textDocument/hover with type information. Design the Hyperon query patterns for completions (backward chaining) and diagnostics (forward chaining). Prototype completion with simple type matching (non-dependent types). Benchmark Hyperon inference latency for interactive use. Survey Rholang contract patterns for M3 generation targets. Budget: Personnel $3,900 (65%). Infrastructure $1,200 (20%: Atomspace, Hyperon, DevNet access). Review $600 (10%). Docs $300 (5%). De-risks M2-M3 by validating that Hyperon inference can respond within LSP latency requirements (<200ms for completions).

Deliverables

D1. LSP Server: Framework with textDocument/hover, project initialization, incremental sync. D2. Atomspace Project Model: MeTTa files parsed into queryable Atomspace with module/type/function atoms. D3. Prototype Completions: Simple type-matching completions via Hyperon backward chaining. D4. Latency Benchmark: Hyperon query response times for completion and diagnostic request types. D5. Rholang Pattern Survey: 5 contract patterns analyzed for type-to-Rholang mapping. D6. Architecture Doc: LSP capabilities, Hyperon query patterns, tiered inference design. D7. Dev Environment: CI/CD pipeline, contributor setup <30 min.

Budget

$10,000 USD

Success Criterion

SC1. LSP server connects to VS Code and provides hover type information. SC2. Prototype completions return type-valid suggestions in <200ms for non-dependent types. SC3. Atomspace correctly represents 3 sample MeTTa projects (modules, types, functions). SC4. Incremental sync updates Atomspace within 100ms of file save. SC5. Architecture reviewed by 2+ community members. SC6. CI/CD passing, setup <30 min.

Milestone 2 - Full Completions + Diagnostic Engine

Description

Production-quality completion engine with dependent type support and the full diagnostic engine with inference chain explanations and fix suggestions. Completions: extend to dependent types (backward chaining with constraint propagation), implement tiered inference (local fast + Singularity Compute deep), streaming deep suggestions, context-aware ranking. Diagnostics: forward chaining type propagation across the project Atomspace, inference chain extraction and natural language rendering, fix suggestion generation via backward chaining for minimal edits. Additional LSP capabilities: textDocument/definition (Atomspace link traversal), textDocument/references (reverse links), textDocument/rename (type-safe), textDocument/codeAction (fix suggestions). VS Code extension with syntax highlighting, inline diagnostics, and completion UI. Budget: Personnel $11,700 (65%). Infrastructure $3,600 (20%: Atomspace hosting, Singularity Compute credits, CI). Testing $1,800 (10%). Docs $900 (5%). Risk: Dependent type inference latency -> tiered architecture with immediate shallow + async deep. Fix suggestion quality -> ranked by minimality with confidence scores.

Deliverables

D1. Completion Engine: Dependent-type-aware suggestions via Hyperon backward chaining with tiered inference. D2. Diagnostic Engine: Forward chaining with full inference chain explanations in natural language. D3. Fix Suggestions: Minimal edits computed by backward chaining, ranked by minimality, with diff preview. D4. Full LSP: definition, references, rename, codeAction, hover — all via Atomspace. D5. VS Code Extension: Syntax highlighting, inline diagnostics, completion UI, fix suggestion UI. D6. Singularity Compute Integration: Deep inference offloading for complex type chains. D7. 250+ tests, CI pipeline, 85%+ coverage.

Budget

$25,000 USD

Success Criterion

SC1. Completions are 100% type-correct for dependent and non-dependent types (zero invalid suggestions). SC2. Diagnostics include full inference chains for 90%+ of type errors. SC3. Fix suggestions resolve the error in 70%+ of cases without introducing new errors. SC4. Tiered inference: shallow completions in <200ms, deep suggestions within 2 seconds. SC5. VS Code extension works end-to-end for 3+ sample projects. SC6. 250+ tests pass, 85%+ coverage.

Milestone 3 - Rholang Generation + Cost Estimation + Polish

Description

Rholang contract generation from MeTTa type specifications with inline cost estimation. Generation engine: MeTTa types -> Rholang process structure via Hyperon inference, channel type mapping, dependent type guards, state machine patterns. Five contract patterns: token, governance, escrow, marketplace, staking. Live preview: edit MeTTa types, see Rholang update inline with type binding annotations. Cost estimation: path enumeration over generated processes, phlo estimation with best/worst case, CBC Casper consensus cost modeling, BlockDAG concurrency cost. Custom LSP capability: metta/rholangGenerate. Polish: error message quality, completion ranking optimization, performance profiling, edge case handling. Budget: Personnel $10,400 (65%). Infrastructure $3,200 (20%: DevNet, Singularity Compute). Testing $1,600 (10%). Docs $800 (5%). Risk: Rholang pattern coverage -> start with 5 well-defined patterns, extensible architecture for community additions. Cost estimation accuracy -> validate against DevNet actual costs, report confidence intervals.

Deliverables

D1. Rholang Generator: MeTTa types -> Rholang for 5 contract patterns (token, governance, escrow, marketplace, staking). D2. Live Preview: Inline Rholang output updates as MeTTa types are edited. D3. Type Binding Annotations: Visual mapping between MeTTa types and Rholang constructs. D4. Cost Estimator: Per-function phlo estimates with best/worst case and CBC Casper costs. D5. BlockDAG Modeling: Concurrent execution cost amplification in estimates. D6. Performance Polish: Completion ranking optimization, diagnostic message quality review.

Budget

$12,000 USD

Success Criterion

SC1. Rholang generation produces compilable contracts for all 5 patterns. SC2. Generated Rholang deploys successfully to DevNet for 90%+ of test cases. SC3. Cost estimates within 25% of actual DevNet phlo costs for 80%+ of contracts. SC4. Live preview updates within 500ms of MeTTa type edit. SC5. Type binding annotations correctly map 100% of MeTTa types to Rholang constructs. SC6. 3+ developers use Tandem for daily MeTTa development during internal testing.

Milestone 4 - Beta Program + Editor Guides + Open Source Launch

Description

Public launch with 10-developer beta, multi-editor support verification, and community release. Beta: developers use Tandem for real MeTTa/Rholang projects, quantitative feedback on completion accuracy, diagnostic usefulness, and Rholang generation quality. Editor guides: VS Code (primary), Neovim, Emacs — LSP configuration for each. Documentation: user guide, completion behavior reference, Rholang pattern catalog, troubleshooting. Open source MIT release on SingularityNET registry. Budget: Personnel $6,500 (65%). Infrastructure $2,000 (20%: DevNet, hosting). Testing $1,000 (10%: beta program). Docs/Marketing $500 (5%). Risk: Beta adoption -> low barrier (install VS Code extension, open project, start typing).

Deliverables

D1. Beta Program: 10 developers use Tandem for real projects. NPS survey. D2. Editor Guides: VS Code, Neovim, Emacs LSP configuration and usage. D3. User Documentation: Complete guide covering completions, diagnostics, fix suggestions, Rholang generation. D4. Rholang Pattern Catalog: 5 contract patterns with type specs and generated output examples. D5. Open Source: MIT license, SingularityNET registry, contributor guide. D6. Demo Video: Full workflow — type MeTTa, get completions, fix errors with inference chains, generate Rholang, see costs.

Budget

$2,000 USD

Success Criterion

SC1. 8+ of 10 beta developers report Tandem completions are more accurate than LLM-based alternatives. SC2. NPS 7+ from beta participants. SC3. LSP works in VS Code, Neovim, and Emacs (confirmed by beta developers). SC4. 50+ GitHub stars within 30 days of launch. SC5. MIT licensed, 85%+ coverage, all tests passing. SC6. Demo video shows complete type-complete-diagnose-fix-generate-cost workflow.

Join the Discussion (0)

Expert Ratings

Reviews & Ratings

No Reviews Avaliable

Check back later by refreshing the page.

The weighted average of the 4 perspectives Overall

0.0
Each RFP defines a maximum allowed budget, but teams can differentiate their proposal by offering a solution with a lower budget or a wider scope.Value for money

0.0
This rating indicates compliance to 'Must haves' but also adaptation of 'Nice to haves' and Non-functional requirements defined in the RFP.Compliance with RFP requirements

0.0
RFPs will offer varying degrees of freedom. This rating indicates the quality of the team's specific solution ideas, the provided details, and the reviewer's confidence in the team's ability to execute.Solution details and team expertise

0.0

Review Headline

0 /50 chars

Review Summary

0 /5000 chars

The weighted average of the 4 perspectives Overall

0.0
Each RFP defines a maximum allowed budget, but teams can differentiate their proposal by offering a solution with a lower budget or a wider scope.Value for money

0.0
This rating indicates compliance to 'Must haves' but also adaptation of 'Nice to haves' and Non-functional requirements defined in the RFP.Compliance with RFP requirements

0.0
RFPs will offer varying degrees of freedom. This rating indicates the quality of the team's specific solution ideas, the provided details, and the reviewer's confidence in the team's ability to execute.Solution details and team expertise

0.0

Review Headline

0 /50 chars

0 /5000 chars

Warning: Adding final group rating for this project will prevent expert users from adding new or editing existing reviews

Reviews and Ratings in Deep Funding are structured in 4 categories. This will ensure that the reviewer takes all these perspectives into account in their assessment and it will make it easier to compare different projects on their strengths and weaknesses. Overall (Primary) This is an average of the 4 perspectives. At the start of this new process, we are assigning an equal weight to all categories, but over time we might change this and make some categories more important than others in the overall score. (This may even be done retroactively). Feasibility (secondary) This represents the user\'s assessment of whether the proposed project is theoretically possible and if it is deemed feasible. E.g. A proposal for nuclear fission might be theoretically possible, but it doesn’t look very feasible in the context of Deep Funding. Viability (secondary) This category is somewhat similar to Feasibility, but it interprets the feasibility against factors such as the size and experience of the team, the budget requested, and the estimated timelines. We could frame this as: “What is your level of confidence that this team will be able to complete this project and its milestones in a reasonable time, and successfully deploy it?” Examples:

A proposal that promises the development of a personal assistant that outperforms existing solutions might be feasible, but if there is no AI expertise in the team the viability rating might be low.
A proposal that promises a new Carbon Emission Compensation scheme might be technically feasible, but the viability could be estimated low due to challenges around market penetration and widespread adoption.

Desirability (secondary) Even if the project team succeeds in creating a product, there is the question of market fit. Is this a project that fulfills an actual need? Is there a lot of competition already? Are the USPs of the project sufficient to make a difference? Example:

Creating a translation service from, say Spanish to English might be possible, but it\'s questionable if such a service would be able to get a significant share of the market

Usefulness (secondary) This is a crucial category that aligns with the main goal of the Deep Funding program. The question to be asked here is: “To what extent will this proposal help to grow the Decentralized AI Platform?” For proposals that develop or utilize an AI service on the platform, the question could be “How many API calls do we expect it to generate” (and how important / high-valued are these calls?). For a marketing proposal, the question could be “How large and well-aligned is the target audience?” Another question is related to how the budget is spent. Are the funds mainly used for value creation for the platform or on other things? Examples:

A metaverse project that spends 95% of its budget on the development of the game and only 5 % on the development of an AI service for the platform might expect a low ‘usefulness’ rating here.

A marketing proposal that creates t-shirts for a local high school, would get a lower ‘usefulness’ rating than a marketing proposal that has a viable plan for targeting highly esteemed universities in a scaleable way.
An AI service that is fully dedicated to a single product, does not take advantage of the purpose of the platform. When the same service would be offered and useful for other parties, this should increase the ‘usefulness’ rating.

Lindqvisk

Project Owner

LSP server architecture, Hyperon query design for completions and diagnostics. PR #847 to Hyperon type inference. Backward/forward chaining from this merged contribution. Milestone check-ins.

View Profile

Account Pending

Blockchain Eng.

Rholang contract generation engine, MeTTa type-to-Rholang mapping, CBC Casper finality encoding, BlockDAG cost modeling, DevNet deployment verification. 12 Rholang contracts deployed to DevNet.

Account Pending

DevEx Engineer

VS Code extension, editor integration guides (Neovim, Emacs), completion UI/UX, diagnostic rendering, beta program coordination, documentation. MeTTa-TypeScript bridge maintainer (200+ stars).

Account Pending