Skip to content
Back to search

solvelang

MarketplaceWorks with Claude CodeGitHub

SolveLang developer tools for Claude

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/saiidz--solvelang/badge.svg)](/listings/saiidz--solvelang)

HTML

<a href="/listings/saiidz--solvelang"><img src="/api/listings/saiidz--solvelang/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Requirements

- Git - Rust and Cargo

Install and run

git clone https://github.com/saiidz/solvelang.git
cd solvelang/solvec
cargo run -- validate ../examples/support_triage.solve
cargo run -- check ../examples/support_triage.solve
cargo run -- run ../examples/support_triage.solve

Inspect tokens or the parsed AST:

cargo run -- tokens ../examples/hello.solve
cargo run -- ast ../examples/hello.solve

Build a release binary:

cargo build --release
./target/release/solvec run ../examples/hello.solve

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 22 lines
  1. {
  2. "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
  3. "name": "solvelang",
  4. "description": "SolveLang developer tools for Claude",
  5. "owner": {
  6. "name": "SolveLang"
  7. },
  8. "plugins": [
  9. {
  10. "name": "solvelang",
  11. "description": "Deterministic, read-only workflow and repository graph analysis through the SolveLang MCP server.",
  12. "version": "0.3.1",
  13. "author": {
  14. "name": "SolveLang"
  15. },
  16. "source": "./plugins/solvelang-claude",
  17. "category": "development",
  18. "homepage": "https://www.solve-lang.com/mcp/",
  19. "displayName": "SolveLang"
  20. }
  21. ]
  22. }
README.md · README · 515 lines
  1. # SolveLang
  2. ## Current verification — 2026-09-20
  3. MCP v0.3.0 is published on npm and GitHub; main protection is enforced.
  4. Older checkpoints below are historical.
  5. > **A readable, explainable workflow language and local-first analysis toolkit for AI-assisted business and coding workflows.**
  6. SolveLang is an early-stage language and tooling project for describing business workflows in a form that humans can read, engineers can review, and organizations can audit. The repository also contains local-first audit/graph tooling, Codex/Claude MCP integration, and the separate **Solve Context** context-selection product layer.
  7. It is not another Zapier, no-code builder, or managed automation platform. Its purpose is to make workflow intent explicit: deterministic rules, AI-assisted decisions, tool access, approvals, expected outputs, failure behavior, and reviewable evidence.
  8. ## Services
  9. SolveLang is the open-source language and toolchain in this repository. SolveLang the service sells four things; three are live today, and the fourth is a pilot and is labeled as one. The full list also lives on the site: [Services](https://www.solve-lang.com/services/). Problem-by-problem guides live in the [Solutions documentation](https://www.solve-lang.com/solutions/).
  10. ### Runner Minutes — live
  11. Prepaid GitHub Actions runner minutes. Buy a pack on the SolveLang site, connect GitHub once (install the app, pick your repositories, accept), and queued jobs in those repositories run automatically on fresh SolveLang-provisioned Linux machines — one machine per job, destroyed when the job ends.
  12. - Metering is per second, measured from each job's own GitHub start and finish timestamps, with a 10-second minimum per job.
  13. - Spot capacity serves first at 1x. If Spot cannot start a job in time, guaranteed on-demand capacity starts it instead, and those minutes draw at 2x — always shown as a separate line in your usage.
  14. - Two pools: Standard (2-vCPU class) and High-Power (16-vCPU class — the Speed lane, with a guaranteed start and a colocated cache).
  15. - Jobs pick their pool by `runs-on` label: `[self-hosted, solvelang-runners-standard]` or `[self-hosted, solvelang-runners-high-power]`. Label routing: label a pull request `solvelang` and its jobs route to SolveLang runners.
  16. - Pause or resume serving at any time from your account. Balances expire 12 months after purchase and are always visible. Linux runners for private repositories.
  17. Prices (USD, tax included — the price shown is the full amount charged):
  18. | Standard minutes | Price | High-Power minutes | Price |
  19. | --- | --- | --- | --- |
  20. | 5,000 | $20 | 1,000 | $80 |
  21. | 25,000 | $100 | 2,000 | $140 |
  22. | 100,000 | $400 | 3,000 | $192 |
  23. | | | 4,000 | $236 |
  24. | | | 5,000 | $275 |
  25. | | | 6,000 | $306 |
  26. | | | 7,000 | $336 |
  27. | | | 8,000 | $360 |
  28. | | | 9,000 | $382.50 |
  29. | | | 10,000 | $400 |
  30. Speed Lane Cache: a 10 GB colocated cache beside the high-power machines, $2 per month. Buying happens only through the site's own embedded checkout: [Buy runner minutes](https://www.solve-lang.com/account/runner-minutes-checkout/).
  31. ### Language, toolchain, and Live Center — live
  32. The SolveLang language and the `solvec` CLI (below), the [browser workspace](https://www.solve-lang.com/run/), Workflow Intelligence Studio, the Repository Audit / Solve Graph / Server Audit surfaces, and Solve Context over MCP. A customer account adds the **Live Center**: a live view of your pull requests, the merge queue, checks, runners, and your minutes balance.
  33. ### API access plans — live
  34. Monthly weighted-credit API plans: Developer $49/month (1,000 credits, 2 API keys), Pro $199/month (10,000 credits, 3 keys), Business $699/month (50,000 credits, 5 keys). Full comparison: [API pricing](https://www.solve-lang.com/api-pricing/).
  35. ### Merge governance (Process Solution) — pilot
  36. Governed merge automation for busy repositories: it builds the exact tree that will land, tests the combined tree once, and lands it only on FULL GREEN, with a written reason for every merge and block. Process Solution is in **pilot** with a small number of design-partner teams — there is no public price and no self-serve signup yet. How it works: [Process Solution](https://www.solve-lang.com/process-solution/). The service is described here only; its source is not in this repository.
  37. ## Why SolveLang exists
  38. Business processes often live in one of three places:
  39. - visual automation canvases that are fast to build but difficult to review and maintain,
  40. - application code that is powerful but hides process intent behind implementation detail,
  41. - prompts and agent configurations that can be hard to audit, test, or govern.
  42. SolveLang explores a middle layer: readable, source-controlled definitions and evidence that can be validated, explained, tested, and eventually adapted to different execution environments.
  43. The long-term goal is not to replace every workflow engine. SolveLang may be most valuable as a specification, analysis, context and explanation layer that works alongside established platforms.
  44. ## Current maturity
  45. SolveLang is an **open-source workflow intelligence product** with a versioned local runtime, browser Studio, and production API/account infrastructure. General managed workflow execution remains gated. This README was reconciled on **2026-09-15** against repository state through PR **#920**. Live GitHub state always wins if that checkpoint becomes stale.
  46. The repository contains a working Rust lexer, parser, AST, interpreter, CLI, diagnostics, implementation-backed 0.1 language specification, explicit local modules, browser/WASM tooling, Workflow Intelligence Studio, bounded Repository/Server Audit surfaces, Self-Driving safety/execution contracts, a substantially implemented Solve Context layer, and a separately deployed production customer-account/API/Admin/TOTP foundation.
  47. It does **not** yet provide a stable 1.0 language contract, production managed workflow execution or enabled paid priority, a generally activated support/provider service, verified marketplace distribution, enterprise orchestration, or a general integration marketplace.
  48. Public claims should use these labels.
  49. ### Working today
  50. - Rust lexer, parser, AST, and interpreter prototype
  51. - CLI commands for running, validating, checking, linting, formatting, tokenizing, and inspecting ASTs
  52. - conservative source-located semantic checks with `solvec check`
  53. - conservative source-located workflow warnings with `solvec lint`
  54. - variables, reassignment, conditions, loops, functions, arrays, objects, JSON helpers, and pure collection/text helpers
  55. - legacy relative-file compatibility includes plus explicit local modules with exports, namespace imports, named imports, live read-only bindings, and deterministic local graph validation
  56. - source-located parser and runtime diagnostics, including imported/module provenance
  57. - deterministic local execution
  58. - hardened execution modes that deny network, file, environment, and agent capabilities
  59. - a local-first Workflow Intelligence Studio with deterministic analysis
  60. - a bounded browser-safe `/run` preview backed by the pinned audited WASM handoff; native `solvec` remains canonical and this is not managed execution
  61. - bounded read-only Repository Audit / Solve Graph and Server Audit product surfaces
  62. - a pure Rust evaluator core and deny-all WASM wrapper with shared conformance and deterministic limits
  63. - repository-safe Self-Driving Observe/Suggest, patch/preflight, single-use execution-plan/finalization, GitHub-write and PostHog safety contracts; live provider activation and production rollout remain separately gated
  64. - **Solve Context** plan/pack/retrieve tools, content-addressed retrieval, Claude ↔ Codex handoff, lossless JSON/log/diff compaction, changed-path + supplied-graph ranking, pinned real-source regressions and strict agent-measurement record/report contracts through #913–#920
  65. - repository-qualified connected-support code with native IMAP/SMTP plus optional Gmail, durable event/action state, safe cutover/recovery, account controls and monitoring preparation; live activation remains separate
  66. - production API access, customer password accounts, private Admin/TOTP infrastructure, live API subscription billing, and live Runner Minutes purchasing on the account pages
  67. - repository examples, tests, schemas, documentation, and launch-readiness controls
  68. ### Experimental
  69. - HTTP GET and POST helpers
  70. - file read/write helpers
  71. - environment-variable access
  72. - `agent`, `instruction`, `tool`, and `ask` syntax
  73. - local AI fallback behavior
  74. - optional OpenAI-backed responses
  75. - Studio-to-`.solve` draft generation
  76. - Solve Context selection/compaction quality beyond the committed regression fixtures
  77. - paid-priority, provider-execution, support-provider activation and managed-execution foundations that remain gated/off in production
  78. Experimental means implemented but unstable, narrow, provider-dependent, not yet broadly distributed, or not suitable for production promises.
  79. Repository validation includes hosted CI plus path-specific Rust/RustSec, WASM, MCP and trusted self-hosted lanes. CI-runner availability is not a released-platform support claim. **SolveLang Runner Minutes is a live service** (see [Services](#services)): prepaid, per-second-metered GitHub Actions runner capacity sold on the SolveLang site, separate from this repository's own CI.
  80. ### Planned / projected
  81. Projection means direction, not a promised date or unsupported completion percentage.
  82. - broader independent/blinded Solve Context evaluation and separately authorized real Claude/Codex baseline-vs-context measurements
  83. - managed-workspace installation and public Plugin Directory evidence for the published MCP package
  84. - maintain the enforced required checks and resolved-review-thread policy on `main`
  85. - a separately reviewed stable 1.0 language contract
  86. - broader type checking
  87. - local package metadata and any future package ecosystem beyond the implemented explicit local-module subset
  88. - additional AI providers and production integrations
  89. - runtime adapters for established orchestration platforms
  90. - full hosted Rust runtime / managed workflow execution only after its own product and safety gates
  91. - owner-authorized public version selection/publication and exact-platform release artifacts beyond current Linux x86_64 evidence
  92. - enterprise governance, durability, and observability
  93. See [`ROADMAP.md`](ROADMAP.md) for the current active queue and completion gates.
  94. ## Quick start
  95. ### Requirements
  96. - Git
  97. - Rust and Cargo
  98. ### Install and run
  99. ```bash
  100. git clone https://github.com/saiidz/solvelang.git
  101. cd solvelang/solvec
  102. cargo run -- validate ../examples/support_triage.solve
  103. cargo run -- check ../examples/support_triage.solve
  104. cargo run -- run ../examples/support_triage.solve
  105. ```
  106. Inspect tokens or the parsed AST:
  107. ```bash
  108. cargo run -- tokens ../examples/hello.solve
  109. cargo run -- ast ../examples/hello.solve
  110. ```
  111. Build a release binary:
  112. ```bash
  113. cargo build --release
  114. ./target/release/solvec run ../examples/hello.solve
  115. ```
  116. ## Solve Context and MCP usage
  117. ### Distribution truth
  118. MCP `@solvelang/mcp-server@0.3.0` is published on npm and GitHub, verified on 2026-09-20. It distributes the tagged release source; later main changes require separate distribution. Managed-workspace marketplace installation and public Plugin Directory listing remain unverified. v0.2.0 is historical.
  119. ### Use current repository source
  120. To evaluate current-main MCP/Solve Context behavior from a source checkout:
  121. ```bash
  122. git clone https://github.com/saiidz/solvelang.git
  123. cd solvelang/packages/mcp-server
  124. npm ci
  125. npm run build
  126. SOLVELANG_WORKSPACE_ROOT=/absolute/path/to/workspace node dist/src/index.js
  127. ```
  128. Current source exposes read-only Solve Context tools including:
  129. - `solvelang_context_plan`
  130. - `solvelang_context_pack`
  131. - `solvelang_context_retrieve`
  132. - `solvelang_context_handoff`
  133. - `solvelang_context_handoff_validate`
  134. - `solvelang_context_compact_structured`
  135. - `solvelang_context_expand_rle`
  136. - `solvelang_context_capabilities`
  137. The MCP server remains local/read-only by default for these context operations. A hosted remote endpoint, provider proxy, repository write path or production deployment is a separate authority boundary.
  138. ### Run Solve Context evaluations
  139. From `packages/mcp-server`:
  140. ```bash
  141. npm run eval:context
  142. npm run eval:context:repository
  143. npm run eval:context:independent
  144. npm run test:context-agent-eval-cli
  145. ```
  146. The first command is synthetic. The repository/independent suites use pinned source snapshots. None of them is a real Claude/Codex token-savings result.
  147. To summarize separately collected approved real-agent records:
  148. ```bash
  149. cat approved-agent-run-records.json | npm run eval:context:agent-records
  150. ```
  151. The summarizer itself performs no provider/network call and uses no credentials. Real records must use the same fixture/provider/model/agent/record class, outcome basis and required-evidence denominator across baseline and Solve Context arms. Public percentage/comparative claims remain disabled until the full acceptance matrix is complete.
  152. ## Example workflow
  153. ```solve
  154. // Support ticket triage for a founder-led team.
  155. let ticket = {
  156. customer: "Acme Labs",
  157. topic: "billing",
  158. priority: "urgent",
  159. plan: "pro"
  160. }
  161. print("Support triage")
  162. print("Customer: " .. ticket.customer)
  163. if ticket.priority == "urgent" {
  164. print("Action: escalate to founder today")
  165. } else {
  166. print("Action: add to normal support queue")
  167. }
  168. if ticket.topic == "billing" {
  169. print("Owner: finance operations")
  170. } else {
  171. print("Owner: support operations")
  172. }
  173. ```
  174. This example is intentionally deterministic. It demonstrates readable business rules without pretending that every decision requires AI.
  175. Run it with:
  176. ```bash
  177. cd solvec
  178. cargo run -- run ../examples/support_triage.solve
  179. ```
  180. ## Explicit local modules
  181. SolveLang 0.1 supports local modules while keeping the older flattened include form as a distinct compatibility mechanism.
  182. ```solve
  183. // math.solve
  184. let private_offset = 10
  185. export let base = 4
  186. export fn add(left, right) {
  187. return left + right + private_offset
  188. }
  189. ```
  190. ```solve
  191. // entry.solve
  192. import "math.solve" as math
  193. import { base as starting_value } from "math.solve"
  194. print(math.add(starting_value, 2))
  195. ```
  196. Explicit modules expose only exported names, keep importer bindings read-only/live, validate the complete local graph before execution, and do not introduce a registry, remote fetch, dependency installer, or package manager. See [`SPEC.md`](SPEC.md) and [`docs/adr/0003-explicit-local-module-syntax.md`](docs/adr/0003-explicit-local-module-syntax.md).
  197. ## CLI commands
  198. ```text
  199. solvec run <file.solve> Run a SolveLang workflow
  200. solvec validate <file.solve> Parse and validate without executing
  201. solvec check <file.solve> Check conservative static semantics without executing
  202. solvec lint <file.solve> Report conservative warnings without executing
  203. solvec fmt [--check] <file.solve> Format source without changing meaning
  204. solvec tokens <file.solve> Print lexer tokens
  205. solvec ast <file.solve> Print the parsed AST
  206. solvec help Show CLI help
  207. ```
  208. Backward-compatible token and AST flags are still supported:
  209. ```bash
  210. solvec <file.solve> --tokens
  211. solvec <file.solve> --ast
  212. ```
  213. The canonical `solvec version` command and non-publishing release-candidate/tag-regeneration gates are implemented. No new public CLI version/tag/release is selected or published merely by those gates, and Linux x86_64 release evidence is supplemented by successful macOS ARM64 and Windows x64 candidate qualification in #941; see [`docs/release-candidate-dry-run.md`](docs/release-candidate-dry-run.md) and [`docs/tagged-release-regeneration.md`](docs/tagged-release-regeneration.md).
  214. ## Runtime safety
  215. By default, `solvec run` executes trusted local scripts with the current runtime capabilities.
  216. Use hardened execution when a workflow must be restricted to pure in-memory evaluation:
  217. ```bash
  218. cargo run -- run --safe ../examples/hello.solve
  219. ```
  220. Any of these options enables the strict policy:
  221. - `--safe`
  222. - `--dry-run`
  223. - `--no-network`
  224. - `--json`
  225. Hardened execution denies sensitive capabilities before evaluation, including in unreachable branches and function bodies:
  226. - network access
  227. - file reads and writes
  228. - environment access
  229. - AI providers and agent use
  230. - agent tools
  231. - unknown or mutation-style functions
  232. A successful hardened run is labeled `NON-PRODUCTION ADVISORY ONLY`.
  233. For deterministic machine-readable execution:
  234. ```bash
  235. cargo run -- run \
  236. --input ../examples/upcomingsounds/cli-contract-input.json \
  237. --json --safe --dry-run --no-network \
  238. ../examples/upcomingsounds/cli-contract.solve
  239. ```
  240. See [`docs/runtime-safety.md`](docs/runtime-safety.md) for the complete policy.
  241. ## Architecture overview
  242. ### 1. Canonical language runtime
  243. `solvec-core/` owns the host-incapable Rust language modules. `solvec/` provides filesystem-backed local modules, host adapters, CLI, runtime policy and the AI-provider boundary. The Rust CLI is canonical.
  244. ### 2. Workflow Intelligence Studio
  245. `site/app/studio/` is a local-first browser workspace for workflow modeling, graph inspection, deterministic analysis, scenarios, traces, local version comparison and evidence export. Its current analysis is deterministic, not model-generated analysis.
  246. ### 3. Website and browser preview
  247. `site/` contains the public website, docs experiences, demos, account screens and the bounded `/run` browser preview. `/run` uses the reviewed pinned same-origin hash-verified WASM handoff and is not managed/server execution.
  248. ### 4. Repository Audit / Solve Graph / Server Audit
  249. These surfaces provide bounded read-only static/system evidence, graph explanations and reports. They do not execute repository source or grant remediation authority.
  250. ### 5. Codex/Claude MCP and Solve Context
  251. `packages/mcp-server/` and `plugins/` contain the shared read-only MCP path. Solve Context performs bounded context selection, packing, retrieval, handoff and correctness-first structured compaction. The measurement harness validates supplied records; it does not launch agents or call providers.
  252. ### 6. Account/API/Admin foundation
  253. `services/api-access/` and related infrastructure contain API-key, customer-account, authentication, Admin, billing-readiness and priority-readiness paths. Separately verified production evidence records API access, customer password accounts, private Admin and TOTP infrastructure as live. API subscription billing is live, and Runner Minutes purchasing is live on the account pages. Paid priority/provider execution and general managed workflow execution remain off/not established live.
  254. ### 7. Connected support
  255. Repository code supports the existing SolveLang mailbox through native IMAP/SMTP plus optional Gmail with durable bounded processing/recovery controls. Deployment, credentials and live task/reply canaries are separate gates.
  256. ## Repository structure
  257. ```text
  258. solvelang/
  259. ├── solvec-core/ Host-incapable Rust language core
  260. ├── solvec/ Native interpreter, host adapters, and CLI
  261. ├── site/ Website, Studio, demos, and browser previews
  262. ├── services/ API/account and supporting services
  263. ├── packages/ MCP and shared packages
  264. ├── plugins/ Codex/Claude integration bundles
  265. ├── examples/ SolveLang workflows and demo assets
  266. ├── docs/ Product, language, safety, strategy, and operations docs
  267. ├── schemas/ JSON schemas and example payloads
  268. ├── ops/ Operational and launch tooling
  269. ├── fixtures/ Test fixtures
  270. └── .github/ CI and workflow automation
  271. ```
  272. ## Documentation
  273. Start here:
  274. - [Active engineering roadmap](ROADMAP.md)
  275. - [0.1 language specification](SPEC.md)
  276. - [Language reference](docs/language-reference.md)
  277. - [Runtime safety](docs/runtime-safety.md)
  278. - [Release contract](docs/release-contract.md)
  279. - [Solve Context v0](docs/product/solve-context-v0.md)
  280. - [Solve Context evals](docs/product/solve-context-evals-v0.md)
  281. - [Codex/Claude MCP integration](docs/integrations/mcp-codex-claude.md)
  282. Live project resources:
  283. - [Website](https://www.solve-lang.com/)
  284. - [Resources](https://www.solve-lang.com/resources/)
  285. - [Support triage demo](https://www.solve-lang.com/demo/support-triage/)
  286. - [Workflow X-Ray audit intake](https://www.solve-lang.com/audit/)
  287. ## Development
  288. ### Rust runtime
  289. ```bash
  290. cd solvec
  291. cargo test
  292. cargo run -- validate ../examples/support_triage.solve
  293. ```
  294. ### Website
  295. ```bash
  296. cd site
  297. npm ci
  298. npm run test:studio
  299. npm run lint
  300. npm run build
  301. ```
  302. ### MCP / Solve Context
  303. ```bash
  304. cd packages/mcp-server
  305. npm ci
  306. npm test
  307. npm run eval:context
  308. npm run eval:context:repository
  309. npm run eval:context:independent
  310. npm run test:context-agent-eval-cli
  311. npm run test:plugin-roundtrip
  312. npm run test:packed
  313. ```
  314. ### API/account services
  315. ```bash
  316. cd services/api-access
  317. npm install --ignore-scripts --no-audit --no-fund
  318. npm test
  319. sam validate --lint --template template.yaml
  320. sam build --template template.yaml
  321. ```
  322. Do not deploy production infrastructure from an unreviewed branch or infer deployment authorization from a repository merge.
  323. ## Contributing
  324. SolveLang evolves quickly, so small reviewable changes are preferred. Before opening a PR: explain the problem, identify the affected layer, separate implemented/experimental/planned claims, add tests for behavior changes, update user-visible docs, avoid unrelated refactors, and include exact validation evidence.
  325. ## Limitations
  326. SolveLang is not currently:
  327. - a stable 1.0 production language/runtime contract
  328. - a replacement for Zapier, Make, n8n, Temporal, Airflow or Camunda
  329. - a production multi-agent platform
  330. - a hosted integration marketplace
  331. - an enterprise compliance product
  332. - a generally live managed workflow execution service
  333. Additional limitations include integer-focused numeric behavior, incomplete type checking, a narrow standard library, local explicit modules only, experimental provider/side-effect features, bounded browser-runtime compatibility, and no published real-agent Solve Context performance benchmark.
  334. ## FAQ
  335. ### Does SolveLang execute workflows today?
  336. Yes. The Rust CLI executes the supported language locally, and a bounded browser preview exists. General managed hosted workflow execution is not live.
  337. ### What is Solve Context?
  338. Solve Context is a separate local-first product layer for Claude Code/Codex context planning, exact context packs, retrieval, handoff and correctness-first compaction. It is implemented in repository source but not yet proven with complete real-agent/provider measurements; the tagged MCP v0.3.0 package is published on npm and GitHub.
  339. ### Does Solve Context save tokens?
  340. The repository has synthetic and pinned-source byte/evidence regressions, not a complete real-agent provider-token benchmark. Do not convert excerpt-byte reduction into a public token-savings percentage.
  341. ### Is the published MCP v0.2.0 the same as current `main`?
  342. No. v0.2.0 is historical. The published v0.3.0 MCP package includes its tagged release source; later main changes require separate distribution.
  343. ### Is Workflow Intelligence Studio AI-powered?
  344. Its current analysis is deterministic and local-first. It should not be described as AI analysis.
  345. ### Is the account/API system production-ready?
  346. A limited customer-account/API/Admin/TOTP foundation is separately deployed and verified. API subscription billing is live and the Developer, Pro, and Business plans are purchasable today; Runner Minutes are likewise purchasable on the account pages. The broader SaaS is not fully launched: paid priority/provider execution, connected-support activation and general managed execution remain separately gated.
  347. ## For recruiters and hiring managers
  348. SolveLang demonstrates work across language/runtime engineering, Rust/TypeScript product surfaces, AWS serverless infrastructure, deterministic analysis/graph tooling, MCP/agent integration, context-selection/evaluation engineering, security/authority boundaries, release engineering and technical product strategy.
  349. The repository is best evaluated as a combined language-runtime, developer-tooling, audit/intelligence, AI-context, cloud-platform and product-strategy project—not as a claim that a finished SaaS already exists.
  350. ## Roadmap
  351. The repository-level engineering roadmap is [`ROADMAP.md`](ROADMAP.md).
  352. Current priorities are:
  353. 1. prove Solve Context with broader independent and real-agent evidence without weakening quality gates;
  354. 2. maintain required checks and resolved review threads on `main`;
  355. 3. verify managed-workspace installation and public Plugin Directory distribution;
  356. 4. keep browser/WASM, language/spec and audit truth implementation-backed;
  357. 5. complete broader billing acceptance and activate support/PostHog/priority only through their separate protected gates;
  358. 6. preserve exact-platform qualification when preparing any public native release.
  359. ## License
  360. SolveLang is licensed under the terms in [`LICENSE`](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.