2026 AI Direction Tracker: Neva for AI Codegen and GenAI Apps

[emil14]

Goal

Create one umbrella tracker for Neva's 2026 AI direction with two coordinated tracks:

1. Neva as an excellent target for AI code generation (LLM-generated Neva code).
2. Neva as an excellent implementation language for applied generative AI systems.

Why now

Neva already has properties that map well to AI-assisted development:

• explicit graph model (1:1 between text and graph),
• explicit imports/namespaces,
• strict static checks and predictable compiler behavior,
• visual-editor direction for human review of generated code.

This issue is for coordination, prioritization, and dependency mapping across both tracks.

Existing baseline (already in progress)

• Stdlib usability stabilization tracker: Stdlib usability stabilization #1033
• Active PRs from that tracker:
  • stdlib/io: add explicit Open/Create/Close file-handle API #1040 (explicit file-handle IO API, related to IO API - Neva vs Go (descriptions and explicit opening/closing) #790)
  • Implement std/os package for env/process/fs primitives #1041 (std/os env/process/fs surface, related to Implement os package for stdlib #586)
  • Redesign stream as union and add streams.Enumerate (#908) #1042 (stream redesign, related to Redesign of stream #908)
• Visual editor (source-level AST representation): Implement Visual Editor for Source Code level (AST) Program Representation #970
• Markdown docs generation from source: Tooling: Markdown Documentation Generation (from Neva Source Code) #973

These are important prerequisites and should be treated as dependencies, not duplicated.

Scope of this umbrella tracker

• Keep one strategic view across the two AI tracks.
• Track dependencies on stdlib/tooling/editor/compiler work.
• Keep child-track goals and acceptance criteria synchronized.
• Periodically summarize progress and re-prioritize.

Child issues

• Track A: Make Neva a top-tier target for AI code generation #1057
• Track B: Make Neva strong for applied generative AI systems #1058

Non-goals

• Not a request to add language-level AI syntax.
• Not a single PR scope.
• Not replacing ongoing stdlib stabilization (Stdlib usability stabilization #1033).

Exit criteria

• Both child trackers have:
  • clearly scoped MVP(s),
  • actionable sub-issues,
  • measurable acceptance criteria,
  • explicit dependency map to existing issues/PRs.
• A documented recommendation exists for 2026 execution order across both tracks.

[emil14]

AgentOps re-trigger after webhook enable: please provide concise plan + acceptance criteria.

[emil14]

I need to authenticate. Since I can't authenticate via the GitHub API without proper credentials, I'll provide the comment content that should be posted:

Implementation Plan for Neva 2026 AI Direction

Based on the analysis of both tracks (#1057 and #1058), here's a coordinated implementation plan with clear dependencies and execution order:

Phase 0: Prerequisites Completion (Current → ~2 weeks)

Track A & B Shared Dependencies:

1. Complete stdlib stabilization (Stdlib usability stabilization #1033) - Finish open PRs:
   • stdlib/io: add explicit Open/Create/Close file-handle API #1040 (file-handle IO API)
   • Implement std/os package for env/process/fs primitives #1041 (std/os expansion)
   • Redesign stream as union and add streams.Enumerate (#908) #1042 (stream redesign)
2. Resolve stream-related gaps - Address No way to interrupt stream producing (iterator protocol/interface, "early return" for stream processing) #666 (producer cancellation) and All stream processors must have err outport #861 (error-port consistency)
3. Establish visual editor foundation (Implement Visual Editor for Source Code level (AST) Program Representation #970) - Source-level AST representation for code review
4. Complete docs generation (Tooling: Markdown Documentation Generation (from Neva Source Code) #973) - Structured API documentation pipeline

Phase 1: Track A First - AI Codegen Tooling (~3-4 weeks)

Goal: Make Neva a top-tier target for AI code generation

Key Deliverables:

1. Enhanced neva doc CLI - Machine-readable structured output with:
   • JSON/NDJSON format option (--format=json)
   • Symbol-level lookup (neva doc --symbol streams.Map)
   • Package API extraction (neva doc --package std/streams)
2. MCP Server Prototype - Minimal Neva language server for agents:
   • Symbol resolution and type signature queries
   • Quick diagnostics explanation
   • Graph-aware navigation endpoints
3. Deterministic Generation Guardrails - Integrate with existing lint/formatter to ensure generated code converges quickly
4. Benchmark Setup - Compare baseline vs improved workflows (tokens/time/retry count)

Phase 2: Track B First - GenAI Systems Foundation (~4-5 weeks)

Goal: Make Neva strong for applied generative AI systems

Key Deliverables:

1. Provider-Agnostic LLM Interface - Third-party module (not stdlib) with:
   • OpenAI-compatible API wrapper
   • Streaming response support with backpressure
   • Tool-calling contract definitions
2. MCP Client/Server Components - Native Neva components for:
   • MCP protocol handling
   • Tool execution with typed contracts
   • Resource discovery and management
3. Reference Application - Tool-using chatbot with:
   • Streaming output
   • Deterministic error handling
   • Concurrent tool execution patterns
4. Pattern Library - Documented building blocks for agent workflows

Phase 3: Cross-Track Integration (~2-3 weeks)

Goal: Connect both tracks for maximum synergy

Key Deliverables:

1. Agent Workflow Examples - Using Track A tooling to generate/maintain Track B applications
2. Integrated Documentation - AI-focused development guide covering both tracks
3. Performance Benchmarks - Measure improvements in developer/agent productivity
4. Roadmap Validation - Update prioritization based on Phase 1-2 learnings

Acceptance Criteria

For Track A (AI Codegen):

✅ CLI Tooling - neva doc supports structured output and focused symbol queries
✅ MCP Surface - Working Neva MCP server with at least 3 core endpoints (symbol lookup, diagnostics, navigation)
✅ Benchmark Results - Show ≥30% reduction in tokens/time for common agent coding tasks
✅ Documentation - Clear examples of AI coding workflows with Neva

For Track B (GenAI Systems):

✅ LLM Integration - Working third-party module for OpenAI API calls with streaming
✅ Tool Calling - Neva-native tool contract system with MCP interoperability
✅ Reference App - Complete, runnable chatbot demonstrating streaming + tools + concurrency
✅ Pattern Library - At least 5 documented composable components for agent workflows

For Umbrella Tracker #1056:

✅ Dependency Map - Clear mapping of all sub-issues to phases
✅ Execution Order - Validated sequencing that minimizes blocking dependencies
✅ Progress Tracking - Regular status updates on both tracks
✅ Exit Criteria Met - Both child tracks have actionable sub-issues with clear acceptance criteria

Recommended Execution Order

1. Complete Phase 0 prerequisites (parallel across teams)
2. Start Track A Phase 1 while Track B defines detailed API contracts
3. Begin Track B Phase 2 once Track A CLI tooling is stable (enables better development experience)
4. Execute Phase 3 integration using lessons from both tracks

This plan creates a virtuous cycle: better AI tooling (Track A) improves development of AI systems (Track B), which in turn validates and informs further tooling improvements.

opencode session  |  github run