How this note was made.
Grove’s research agent (0.2.0) drafted it on using local Gemma 4 (31B Dense) model , served by Ollama on a Mac M3 Max.
It read 40 sources: 30 web pages, the research brief and nine of Grove’s own documents. From them it kept 128 quotes, each checked word for word against a stored copy of its source.
I have approved the draft on 7 November 2026. Claude currently acting as an orchestrator without intelligence in the absence of interface and GPT helped me format for links, tables, and graphics used in this post shared.
Every factual statement below rests on one of those quotes, cited as [En] and listed under Sources at the end. Where the sources are silent, the note says so.
[All web pages were retrieved on 7 November 2026]
Executive summary
Research Brief and Architectural Context.
I have asked for the evidence behind “our case of leveraging TypeScript SDK” to back on my decision as well as cross verifying before final call. It was to go beyond “developer community fondness and support” and cover the current status of support, future efforts and, “most importantly current trade offs” [E12].
Grove’s recorded position is that it is TypeScript-first, with language-neutral contracts so that parts of it can later move to Python [E13][E1].
The case, beyond fondness.
The evidence gives four reasons:
Types plus run-time schemas. Both Claude SDKs and four of the five other agent toolkits in the run pair TypeScript types with a schema library that also checks data at run time, usually Zod (section 2.2).
Types as contracts. DeepSeek typed its harness’s wire protocol so that “server drift breaks compilation, not clients” [E70]. Grove’s plan makes bypassing its gateway, router or recorder a compile error [E3].
Agent-assisted coding. GitHub links TypeScript’s rise to “agent-assisted coding” [E107]. A 2025 paper uses type systems to constrain model-generated code, and extends the method to TypeScript [E128].
The SDKs exist and are actively released.
Both of Claude’s SDK layers have TypeScript editions.
Anthropic’s API SDK for TypeScript shipped at least nine releases between 15 September and 5 November 2026, including 1.0.0 on 21 October 2026 [E56].
DeepSeek’s design note of 27 July 2026 records building a TypeScript SDK for its harness [E68].
Five other agent toolkits ship for TypeScript (section 5).
Future efforts
TypeScript 7.0, a native port written in Go, reached beta on 21 April 2026. It is “often about 10 times faster than TypeScript 6.0” [E93], and it’s release was planned “within the next two months” [E94]. Whether it has shipped is not in the evidence. Node.js now runs TypeScript directly by stripping types, a feature its documentation marks as stable [E99].
Limits of the case.
Quality evidence is mixed. The one direct study found better code quality and understandability in TypeScript applications than in JavaScript ones, but not fewer bugs or faster fixes [E120][E121].
Python leads in AI. Python “remains dominant for AI and data science workloads” [E108].
Popularity measures disagree. TypeScript is first on GitHub [E110] but sixth in the 2026 Stack Overflow survey [E116].
Types vanish at run time. Node.js checks no types when it runs TypeScript [E101], and running it directly rules out some syntax [E103][E104].
DeepSeek’s TypeScript SDK is not an API client. It drives the DeepSeek Harness [E64]. For its model API, DeepSeek’s documentation points to OpenAI’s and Anthropic’s SDKs [E75].
The SDK comparison is thin. The run’s evidence on Claude’s Python Agent SDK shows it following the TypeScript one on three points [E38][E39][E40], and holds no fuller comparison.
For Grove.
The evidence supports TypeScript-first with language-neutral contracts. It contradicts nothing in Grove’s recorded position. Most of what it suggests adopting or avoiding is already settled by Grove’s decisions: one schema serving as both the type and the run-time check; a separate type check; Python only for the parts that move, behind a planned subprocess protocol with cancellation and a timeout. Five points are open or only partly settled (section 10):
the cost of a full runtime per child process;
the syntax limits of running TypeScript directly;
how Claude’s Agent SDK would sit beside Grove’s own runtime;
whether DeepSeek’s API works through Grove’s existing OpenAI-compatible route;
keeping use of
anylow.
1. The Research Brief and the positions being tested
I have noted that Claude and DeepSeek have both developed TypeScript SDKs, and asked to deep dive beyond the “obvious reason” of community fondness to establish four things:
why it is good to use a TypeScript SDK;
the current status of support;
future efforts from the communities;
most importantly, the current trade-offs [E12].
Grove’s own records state the position being tested:
Grove’s decision record on language-neutral contracts says: “Grove is TypeScript-first.” It names the team’s machine-learning codebase as Python, and as the place where an in-house language model is planned to evolve [E13].
Grove’s implementation plan records the my own decision that some Grove modules will move into that codebase later, so Grove “stays TypeScript with language-neutral contracts” [E1]. Its decision log marks portability as decided on the same terms [E6].
These are stated positions, not findings. Sections 2 to 8 set out what the external sources say. Section 9 tests Grove’s position against them, and section 10 draws out what Grove should adopt or avoid.
2. Why TypeScript for agents, beyond community fondness
2.1 What static types are argued to buy
The 2022 paper “To Type or Not to Type? A Systematic Comparison of the Software Quality of JavaScript and TypeScript Applications on GitHub“ reports what proponents of static typing claim. They say it “allows early detection of some programming errors” and leads to “better documentation in the form of type signatures” [E119]. The paper’s own background section is more cautious. For smaller applications, dynamic typing’s flexibility “could be preferable”, while larger systems “might be more sustainable with static typing” [E125]. What the same paper measured is in section 8.1.
2.2 Schemas: types that also check data at run time
TypeScript’s types do not exist when the program runs (section 8.2). The sources show agent SDKs pairing them with schema libraries that validate data at run time:
The Claude Agent SDK’s
tool()takes a Zod schema for a tool’s input, and types the handler’s arguments from that schema [E32].The Claude API’s TypeScript SDK describes tool inputs with “Zod schemas or JSON Schemas” [E45].
The Vercel AI SDK’s README generates structured model output against a Zod schema [E84].
The OpenAI Agents SDK’s install command adds
zodbeside the SDK [E80].Google’s Agent Development Kit for TypeScript lists “Zod schema validation” among its features [E92].
The MCP TypeScript SDK accepts any Standard Schema library: “bring Zod v4, Valibot, ArkType, or any compatible library” [E77].
Grove’s plan uses zod for its schemas and for their JSON Schema export [E4].
2.3 Types as contracts between components and processes
Three sources use compile-time types to hold a boundary:
DeepSeek’s wire protocol. DeepSeek’s design note for its TypeScript SDK, dated 27 July 2026, describes its protocol package as “the wire made shared and nominal”: one module names every payload the server speaks [E69]. Because the server’s
notify()calls are typed against those names, “server drift breaks compilation, not clients” [E70].Grove’s dependency rule. In Grove’s plan, every library depends only on Grove’s public contracts package, and the applications are the only place implementations meet. Package dependencies and a dependency checker enforce the rule. Agents see only the contracts package, “so bypassing the gateway, router or recorder is a compile error” [E3].
Typed tool results. Version 0.3.292 of the Claude Agent SDK for TypeScript added typed
sectionsandnotesto a tool’s result, “so hosts can list agents without parsing its text” [E26].
2.4 Types that flow from a definition to its users
The Vercel AI SDK’s README derives an agent’s message type directly from the agent’s definition [E86]. It also types a UI component’s tool invocation from the tool’s own return type [E87]. The examples show the mechanism. No source in the run measures its benefit.
2.5 Models writing code against types
A 2025 paper on constrained decoding. “Type-Constrained Code Generation with Language Models“ introduces “a type-constrained decoding approach that leverages type systems to guide code generation”. The method is meant to “enforce well-typedness on LLM-generated code”. The authors formalise it on a simply-typed language, then “extend it to TypeScript to demonstrate practicality” [E128].
GitHub’s 2025 reading. GitHub’s Octoverse 2025 report says TypeScript’s rise “illustrates how developers are shifting toward typed languages that make agent-assisted coding more reliable in production” [E107].
GitHub’s 2026 data. Octoverse 2026 found TypeScript to be the primary language in 35% of repositories created in 2026 that showed an agent signal, against 24% of those without one [E114]. GitHub reads this as suggesting that “developers who work with agents gravitate toward languages where agent output is easier to check” [E115]. That reading is GitHub’s interpretation of a correlation, not a measured cause.
2.6 Where the code runs
Each SDK states its own runtimes. These are properties of the SDKs, not of the language.
3. The status of Claude’s TypeScript SDKs
Anthropic’s overview of its SDKs and libraries says that “Claude Code, the Claude Agent SDK, and Claude Managed Agents work at a higher level, providing the agent loop, tool execution, and runtime” [E41]. Below that level sits the Claude API’s own client SDK. Each layer has a TypeScript SDK: the Agent SDK (section 3.1) and the API SDK (section 3.2). The documentation pages are undated. The Agent SDK changelogs give version numbers without dates, and the API SDK changelog gives both.
3.1 The Claude Agent SDK for TypeScript
What it offers.
Purpose. Its README says it lets developers “programmatically build AI agents with Claude Code’s capabilities”: agents that can “understand codebases, edit files, run commands, and execute complex workflows” [E17].
Bundled binary. It bundles a native Claude Code binary for the platform as an optional dependency, such as
@anthropic-ai/claude-agent-sdk-darwin-arm64. “Most installs need no separate Claude Code install.” [E28]Streaming.
query()is the primary function. It “creates an async generator that streams messages as they arrive”, and takes either a string or an async iterable of user messages as its prompt [E31].Tools and MCP.
tool()defines a typed tool from a Zod schema [E32].createSdkMcpServer()defines an MCP server from a name, a version, instructions and such tools [E35].Sessions. It provides session helpers, including
listSessions()andgetSessionMessages()[E36][E37].Prewarming.
prewarm()returns a spare process [E34]. It is alpha, was added to the/coreentry in version 0.3.314 [E18], and requires Agent SDK v0.3.282 or later [E33].Bundling. An application that bundles the SDK with its own dependencies should import the
/coreentry, which needs Agent SDK v0.3.282 or later, and TypeScript 5.0 or later for its types [E30]. The root entry inlines its own copies ofzodand the MCP SDK./coretakes them from the application’s ownnode_modulesinstead, so a bundle does not carry a second copy [E29].
Recent changes (in the newest 720 lines of the changelog, which carries no dates):
How actively it is released. The cited entries run from version 0.3.292 to 0.3.319, and the newest tracks Claude Code v2.1.319 [E21]. Because the changelog has no dates, the evidence cannot say how often these versions shipped.
3.2 The Claude API’s TypeScript SDK
What it offers.
Types. TypeScript definitions “for all request parameters and response fields” [E43].
Streaming and batches. Streaming responses over Server-Sent Events [E44], and batch processing under
client.messages.batches[E49].Tool helpers. Tools are described with Zod schemas or JSON Schemas and run with
client.beta.messages.toolRunner(), a beta method [E45]. A tool can throw aToolError, which, unlike a plainError, can carry images or other structured content back to the model [E46].MCP helpers. Helpers convert MCP tools, prompts and resources to Claude API types [E47]. They throw
UnsupportedMCPValueErrorfor values the API does not support, such as an unsupported content or MIME type, or a non-HTTP/HTTPS resource link [E48].File uploads. Uploads accept a
File, afetchResponse, anfs.ReadStreamor the output oftoFile[E50].Errors. A connection failure or a 4xx or 5xx response throws a subclass of
APIError[E51].Runtimes. The runtimes listed in section 2.6 [E42].
How actively it is released. The changelog is dated:
The cited entries alone show nine releases in about seven weeks, and a 1.0.0 release tied to a new API version. This is the most precisely dated evidence of release activity in the run. The fetch truncated this changelog and the run read only its first 720 lines, so older history is not covered.
3.3 Compared with the Python SDKs
Three entries in the changelog of the Claude Agent SDK for Python describe changes made to match the TypeScript SDK:
0.2.160. The SDK now listens for the CLI’s
session_state_changedmessages and keeps stdin open until the CLI reportsidle, “matching the TypeScript SDK’s behavior” [E38].0.2.140. A new
forward_subagent_textoption forwards a subagent’s text and thinking blocks into the stream. It “Matches the TypeScript SDK’sforwardSubagentText“ [E39].0.2.126.
ResultMessage.model_usageis now typed with aModelUsageTypedDict that “mirrors the TypeScript SDK’s shape” [E40].
On these three points the TypeScript SDK had the behaviour first. The Python changelog is undated.
The evidence holds no full comparison of the two languages’ SDKs, and nothing on where the Python SDKs lead. The run fetched the Python Agent SDK’s README and the Claude API’s Python SDK page, but kept no quote from either (section 11).
4. The status of DeepSeek’s TypeScript SDK
4.1 What DeepSeek Harness is
DeepSeek Harness (dsh) is “an open-source agent harness developed by DeepSeek AI”. It is built on an “everything-is-a-plugin” architecture and powered by Cordis [E62]. Its README‘s quick start is to install Node.js and run it with npx [E63]. The README is undated.
4.2 The TypeScript SDK family
The SDK “lets another process drive a complete DeepSeek Harness runtime over newline-delimited JSON-RPC” [E64]:
its protocol package defines the public messages;
the TypeScript client launches
dshwith a named profile and ordered patches;the server accepts SDK requests over stdio.
It has three packages [E65]:
PackageRoleprotocol/The newline-delimited JSON-RPC transport, and the named request, result and notification typesclient/A TypeScript client that spawns a runtime subprocess and drives agent turns through high-level and protocol-level APIsserver/A jsonrpc plugin that serves out-of-process SDK clients over stdio
DeepSeek’s architecture document adds that the TypeScript SDK resolves a dsh dependency of the same version and selects the sdk profile. Custom plugin composition remains “a profile plus ordered patch files, not another executable or inline application tree” [E73].
DeepSeek’s TypeScript SDK is therefore not a client for DeepSeek’s model API. It drives the harness as a subprocess [E64]. For the model API, see section 4.6.
4.3 It’s Python counterpart
The Python SDK “speaks the same protocol and ships a bundled runtime” [E66]. It is a “Python subprocess SDK for driving DeepSeek Harness over newline-delimited JSON-RPC on stdio” [E67]. It “follows the same application architecture”: its runtime wheel packages the normal dsh CLI, and by default the client launches dsh --profile sdk with an explicit Harness home [E74].
4.4 Why it was built
DeepSeek’s design note, dated 27 July 2026, gives the reason. “TypeScript consumers wanting the same drive-a-harness-as-a-subprocess capability — repo tests, automation, and above all a subagent backend whose child is a complete harness runtime rather than a generic ACP agent — had nothing to import” [E68]. The design made the wire shared and nominal [E69], so that server drift breaks compilation rather than clients [E70].
4.5 The limits its own documents state
The design note lists two costs of the design:
A full runtime per child. “the SDK backend boots a complete plugin tree per child (heavier per-run than an ACP child; pooling remains future work, same as ACP)” [E71].
No cancel method. “the wire still has no cancel method, so both the SDK’s
RequestTimeoutErrorand the backend’s dispose settle locally while the server-side turn runs on until process teardown” [E72].
The evidence does not say whether either cost has been addressed since. The run also fetched DeepSeek Harness’s safety notice, but kept no verified quote from it. This note therefore cannot report the limits that notice states (section 11).
4.6 What DeepSeek’s API documentation says about client libraries
“The DeepSeek API uses an API format compatible with OpenAI/Anthropic. By modifying the configuration, you can use the OpenAI/Anthropic SDK or softwares compatible with the OpenAI/Anthropic API to access the DeepSeek API.“ [E75] The page is undated. The quoted passage names no DeepSeek client library.
5. The wider TypeScript agent ecosystem
Each project is described from its own README. The READMEs are undated, and no source in the run ranks the projects against each other.
Three more points from these sources:
OpenAI states: “We’re committed to building the Agents SDK as an open source framework so others in the community can expand on our approach.” [E81]
GitHub’s Octoverse 2025 report notes that the Model Context Protocol “hit 37k stars in just eight months”, though it is not on the report’s ranked lists [E109].
Four of the five projects name Zod, or a schema standard that includes it. Two describe themselves as provider-agnostic [E78][E82].
6. Future efforts
6.1 TypeScript 7: the native compiler
The March 2025 plan. “A 10x Faster TypeScript“ (11 March 2025) announced a native port of the compiler and tools. The port would “drastically improve editor startup, reduce most build times by 10x, and substantially reduce memory usage” [E96]. Its plan at the time was:
a preview of a native
tscfor command-line type checking by mid-2025;a feature-complete solution for project builds and a language service by the end of 2025 [E97];
a release as TypeScript 7.0 once the native codebase “has reached sufficient parity” [E98].
This was the plan as of March 2025, not a record of what happened.
The April 2026 beta. “Announcing TypeScript 7.0 Beta“ (21 April 2026) reports that the codebase had been ported from TypeScript to Go over the past year. With native code speed and shared-memory parallelism, “TypeScript 7.0 is often about 10 times faster than TypeScript 6.0” [E93]. The post said: “Our current plan is to release TypeScript 7.0 within the next two months” [E94]. Two months from the post would be about late June 2026. A stable programmatic API is planned “for TypeScript 7.1 or later” [E95].
What is not known. Whether TypeScript 7.0 has shipped as a stable release is not in the evidence. The newest dated evidence of a compiler in use is Anthropic’s API SDK building its sub-packages with TypeScript 6.0.3, in version 0.127.0 of 18 September 2026 [E61].
6.2 Node.js runs TypeScript directly
Node.js documentation states: “Type stripping is now stable.” [E99] Its version history records this for Node.js v25.2.0 and v24.12.0.
How it works. By default Node.js “will execute TypeScript files that contains only erasable TypeScript syntax”. It replaces that syntax with whitespace, “and no type checking is performed” [E101].
Why it is light. The feature is designed to be lightweight. It deliberately leaves out syntax that needs JavaScript code generation, so Node.js runs TypeScript without source maps [E102].
The two options. Node.js documents two ways to run TypeScript. A third-party package gives “full support of all of TypeScript’s syntax and features, including using any version of TypeScript”. The built-in type stripping gives “lightweight support” [E100].
The limits this brings are in section 8.3.
6.3 The SDKs’ stated directions
The evidence holds no roadmap for any SDK beyond these statements:
OpenAI commits to the Agents SDK as an open-source framework [E81].
DeepSeek lists pooling of SDK children as “future work” [E71].
The Claude Agent SDK tracks Claude Code: its latest entry is “Updated to parity with Claude Code v2.1.319” [E21].
The Claude API SDK reached 1.0.0 with a new API version on 21 October 2026 [E56].
TypeScript plans a stable programmatic API for 7.1 or later [E95].
7. Community evidence
Further points from these sources:
AI involvement in pull requests. Octoverse 2026 reports that TypeScript, Python and Rust, “the fastest-growing communities, have the highest shares, about 40% to 44% of merged pull requests” [E113]. In the report this is each language’s share of merged pull requests with detected AI involvement, not TypeScript’s share of all pull requests.
Python’s place. The same 2025 report that ranks TypeScript first adds: “Python remains dominant for AI and data science workloads, while the JavaScript/TypeScript ecosystem still accounts for more overall activity than Python alone” [E108].
The same split in 2021. The 2022 paper cited the 2021 Stack Overflow survey for JavaScript being the most widely used language [E123], and Octoverse for TypeScript’s growing popularity [E124].
Why the measures disagree. Octoverse counts contributors on GitHub [E110], while the survey counts respondents [E117]. They measure different populations, so they can disagree without either being wrong.
8. The trade-offs
I have called the trade-offs the most important part of the question [E12]. The evidence supports nine. Each ends with its bearing on Grove.
8.1 Better code quality, but not fewer bugs
The 2022 paper “To Type or Not to Type? A Systematic Comparison of the Software Quality of JavaScript and TypeScript Applications on GitHub“ compared JavaScript and TypeScript applications. Its abstract reports three findings:
Quality. “TS applications exhibit significantly better code quality and understandability than JS applications” [E120].
Bugs. “Contrary to expectations, however, bug proneness and bug resolution time of our TS sample were not significantly lower than for JS.” The mean bug-fix commit ratio of the TypeScript projects was more than 60% larger (0.206 against 0.126), and they took on average more than a day longer to fix bugs (33.04 against 31.86 days) [E121].
The
anytype. Usinganyless “appears to be beneficial”: its frequency correlated significantly with every metric except bug proneness [E122].
That is the real tension in the evidence: better quality and understandability, but no lower bug proneness, in the same study [E120][E121].
The paper’s related-work section describes earlier studies, with their own samples, that lean the other way:
Zhang et al. (2020): “Within their sample, dynamically typed languages consumed 59.5% more time for bug resolution than statically typed ones.” [E126]
Gao et al. (2017): using TypeScript “would have prevented 60 of the 400 bugs they examined (15%)” [E127].
These are different studies, not more data from the 2022 paper’s sample. No source in the run studies agent harnesses or SDK codebases specifically.
For Grove: the evidence supports types for code quality and understandability. It does not promise fewer bugs.
8.2 Types are erased at run time
In the 2022 paper’s description, “TS performs type checking at transpile-time, while JS performs type checking at run-time” [E118]. Node.js’s type stripping replaces TypeScript syntax with whitespace and performs no type checking [E101]. Two things follow:
Data that crosses a boundary, such as model output, tool input or a message between processes, needs a run-time schema (section 2.2).
The type check has to run as a step of its own.
For Grove: it does both. Every persisted or exchanged structure is a zod schema [E14], and the type check runs across all packages [E11] and in CI [E8].
8.3 Running TypeScript directly has syntax limits
Type stripping runs only erasable syntax [E101]:
Transformed features fail. Enum declarations, namespaces with runtime code, parameter properties and import aliases need transformation rather than stripping [E103].
Decorators fail. They are not transformed and cause a parser error. Node.js “will not support decorators until they are supported natively in JavaScript” [E104].
Type imports need the
typekeyword. Without it Node.js treats a type import as a value import, which is a run-time error [E105].Full syntax needs a package. Full TypeScript syntax, or a chosen TypeScript version, needs a third-party package [E100].
For Grove: its first milestone report says there is no build step, because Node runs the TypeScript directly [E9]. Its plan lists tsx and tsup for development and build [E4]. The evidence does not say which mechanism Grove’s direct run uses, so whether these limits bind Grove is a gap.
8.4 Python’s place in AI and machine learning
Dominance. Python “remains dominant for AI and data science workloads” [E108].
Contributors. It is second on GitHub [E110], added 3.23 million monthly contributors in a year [E111], and is forecast to reach about the same size as TypeScript by September 2027 [E112].
Survey use. 58.0% of the 2026 survey’s respondents use it, against 43.8% for TypeScript [E117].
The evidence states Python’s dominance in AI in one sentence. No source compares the two languages’ machine-learning libraries.
For Grove: its records already keep a Python boundary. Its machine-learning codebase is Python [E13], and three ports may be re-implemented in Python: the model provider, the context source and the scorer [E16].
8.5 Where the Python SDKs lead or differ
The only comparison in the evidence is the three Python changes made to match the TypeScript Agent SDK [E38][E39][E40]. Nothing in the evidence shows where Python leads.
For Grove: the evidence neither confirms nor rules out a Python-only capability that Grove would miss.
8.6 The cost of keeping two languages
DeepSeek keeps two SDKs over one protocol [E66][E67][E74]. It built the TypeScript one because TypeScript consumers “had nothing to import” [E68].
Anthropic keeps the Python Agent SDK in step with the TypeScript one by matching its behaviour, options and types one change at a time [E38][E39][E40].
In both cases a single shared protocol or shape holds the two languages together. No source counts what that costs.
For Grove: it avoids a second SDK by design:
one TypeScript implementation;
contracts any language can read, exported as JSON Schema [E14];
digests any language can reproduce [E15];
a subprocess protocol only for the ports that move [E16].
8.7 Subprocess SDKs cost runtime and need cancellation
DeepSeek’s design boots a complete plugin tree for each child, and has no pooling yet [E71]. Its wire has no cancel method, so a timed-out turn keeps running on the server until the process is torn down [E72].
For Grove: its planned subprocess protocol maps cancellation to SIGTERM and has a timeout [E16]. Section 10 covers the open part.
8.8 Popularity measures disagree
TypeScript is first on GitHub by contributors [E110] and sixth in the 2026 Stack Overflow survey [E116][E117]. Popularity alone does not settle the case either way.
For Grove: the case rests better on sections 2 to 4 than on rankings.
8.9 Compiler speed and stability are in transition
The TypeScript 7.0 beta is reported as often about ten times faster than 6.0 [E93]. A stable programmatic API comes only with 7.1 or later [E95], and the evidence does not show that 7.0 has shipped (section 6.1).
For Grove: no Grove decision in the evidence addresses TypeScript 7.
9. Grove’s recorded position against the evidence
9.1 What Grove has recorded
TypeScript-first. Grove is TypeScript-first [E13], and stays TypeScript with language-neutral contracts because some modules will later move to the Python machine-learning codebase [E1][E6].
One schema per structure. Every persisted or exchanged structure is defined once as a zod schema in Grove’s public contracts package, and exported as JSON Schema with a schema version [E14][E2][E10]. This covers run records, run events, artifacts, provenance, memory entries, model selection, messages, errors and configuration [E14].
Portable digests. Digests use canonical JSON (keys sorted recursively, undefined values dropped) followed by sha256, “so any language reproduces them” [E15].
A subprocess protocol, planned. Ports that may be re-implemented in Python will get a local subprocess protocol: NDJSON request and response over stdio, schema-validated messages, cancellation mapped to SIGTERM, and a timeout [E16]. The plan’s risk register lists the TypeScript–Python split as an architecture risk. Its mitigation is that protocol plus a schema conformance script [E7].
Checks. Grove’s traceability table marks its TypeScript-first typed contracts as tested, by a unit test and by the type check in CI [E8]. The first milestone report lists the type check across all packages, and a lint step for the dependency rule [E11].
Models. Grove’s private expert is a local OpenAI-compatible model server (Ollama on CPU-only hosts, vLLM on a GPU host), reached through Grove’s OpenAI-compatible provider at a configured address [E5]. The plan lists Anthropic’s TypeScript SDK and the AWS Bedrock runtime client as optional dependencies of Grove’s model router [E4].
9.2 Where the evidence supports it
Static types and compile-time boundaries. These are argued for by proponents [E119], used by DeepSeek [E69][E70], and used in Grove’s own dependency rule [E3].
Schema-first contracts. They match how the Claude SDKs, the Vercel AI SDK, the OpenAI Agents SDK, Google’s ADK and the MCP SDK handle schemas [E32][E45][E84][E80][E92][E77].
TypeScript SDKs exist and are maintained. The Claude API SDK shows frequent dated releases (section 3.2). On three points, the Python Agent SDK followed the TypeScript one [E38][E39][E40].
DeepSeek also puts a protocol between languages. It runs one wire protocol with TypeScript and Python SDKs on top [E64][E66][E67], the approach Grove plans for the ports that move to Python [E16].
Agent use. GitHub links TypeScript’s rise to agent-assisted coding, and finds it more common in repositories with agent signals. These are GitHub’s interpretation [E107][E114][E115].
9.3 Where the evidence qualifies it
Mixed quality evidence. Code quality and understandability are better, but bug proneness is not lower [E120][E121]. Limiting
anyappears to help [E122].Python’s lead in AI. Python is dominant for AI and data science [E108]. Grove’s records already keep a Python boundary for the machine-learning codebase [E13].
Erased types. Types are erased at run time [E101], so Grove’s run-time schemas are necessary, not optional.
Direct-run syntax limits. Running TypeScript directly limits the syntax that can be used [E103][E104][E105]. Whether this binds Grove is a gap (section 8.3).
Popularity. The popularity measures disagree [E110][E116][E117].
Subprocess costs. Subprocess designs carry runtime and cancellation costs [E71][E72].
9.4 Where the evidence contradicts it
Nothing in the evidence contradicts Grove’s recorded position outright. The nearest is the 2022 paper’s finding that TypeScript projects did not have fewer bugs [E121]. That qualifies the general argument for static types [E119], not Grove’s design.
10. What Grove should adopt or avoid
Each point below is drawn only from the evidence above. The last column says whether a Grove decision quoted in the evidence already settles it.
No row proposes new components. Rows 6, 7, 10 and 12 need an owner decision, or evidence the run did not gather. Row 8 needs a test.
11. Conflicts, gaps and coverage limits
11.1 Conflicts
The real tension. Within the 2022 study, TypeScript applications had better code quality and understandability [E120], but bug proneness and bug resolution time were not lower [E121].
Not a conflict: how TypeScript is checked and run. The 2022 paper describes TypeScript as transpiled by
tsc, with types checked at transpile time [E118]. Node.js can run erasable TypeScript directly, with no type checking [E101][E102]. That is one way a project can have no build step, as Grove reports [E9], with type checking as a separate step [E11].Not a conflict: the 59.5% figure. Zhang et al.’s result [E126] comes from a different study and sample than the 2022 paper’s own [E121].
Not a conflict: the popularity rankings. GitHub and Stack Overflow measure different populations (section 7).
11.2 Gaps: what the sources do not say
Whether TypeScript 7.0 has shipped as a stable release. The newest evidence is the 21 April 2026 plan [E94].
A full feature comparison of Claude’s TypeScript and Python SDKs, or where the Python SDKs lead.
Release dates for the Claude Agent SDK’s TypeScript and Python versions. Both changelogs give versions only.
The limits stated in DeepSeek Harness’s safety notice. It was fetched, but no verified quote was kept.
Whether DeepSeek has addressed the per-child cost or the missing cancel method since July 2026 [E71][E72].
A comparison of TypeScript’s and Python’s machine-learning ecosystems, beyond one sentence [E108].
Evidence on software quality in agent harnesses or SDK codebases specifically. The studies cover general GitHub applications [E120][E121][E126][E127], and type-constrained code generation [E128].
The cost of maintaining SDKs in two languages.
Which mechanism Grove’s direct run of TypeScript uses [E9][E4].
Whether Grove’s subprocess protocol has been built [E16][E6], and whether DeepSeek’s API has been tried through Grove’s OpenAI-compatible provider [E5][E75].
Roadmaps for any of the SDKs, beyond the statements in section 6.3.
11.3 Coverage limits
Long pages were read only in part. The run read the first 720 lines (six windows of 120 lines) of each long page. The pages affected are:
the Claude Agent SDK changelogs for TypeScript and Python;
the Agent SDK’s TypeScript reference;
the Claude API’s TypeScript and Python SDK pages;
the Anthropic TypeScript SDK changelog;
both Octoverse reports;
the 2022 paper, all but its last five lines.
Older changelog history and later sections were not read.
Two pages were truncated. The fetch truncated the Agent SDK’s TypeScript reference and the Anthropic TypeScript SDK changelog, so only their start was examined.
Eight Grove documents were not read. The run reads at most ten local sources. Five decision records, two milestone reports and an operations note ranked below the top ten and were not read.
Some sources gave no quotes.
Five of the nine Grove documents read yielded no quote.
Four fetched web pages gave no verified quote: the Claude Agent SDK overview, the Python Agent SDK README, the Claude API’s Python SDK page and DeepSeek Harness’s safety notice.
Rejected quotes are a coverage limit, not missing material. 54 candidate quotes were rejected because the model paraphrased instead of copying. The rejected quotes are not used here, and nothing is missing from the sources.
Sources
Each cited id maps to one source below. Grove’s own documents are described by their role. Web pages were retrieved on 7 November 2026.
Research brief and Grove’s own documents
1. Research brief
1. Owner’s brief: the case for TypeScript SDKs in Grove
Evidence: E12
Role: My request for this deep dive, recorded word for word
Date: 7 November 2026
2. Grove v0.1 — discovery, implementation and traceability
2. Grove v0.1 — Phase 0 discovery report and implementation plan
Evidence: E1–E7
Role: Grove’s plan, decision log and risk register
Date: Last updated 20 October 2026
3. Grove v0.1 traceability
Evidence: E8
Role: Grove’s table mapping each component to its code and its tests
Date: Undated; read as of 7 November 2026
4. Grove v0.1 — first milestone report (agent foundation)
Evidence: E9–E11
Role: Grove’s first milestone report
Date: 20 October 2026
3. Language-neutral architecture and portability
5. Language-neutral contracts for portability to the machine-learning codebase
Evidence: E13–E16
Role: Grove’s decision record on language-neutral contracts
Date: 20 October 2026
Web sources
All web pages were retrieved on 7 November 2026. Evidence IDs in brackets correspond to citations in the article.
1. Anthropic — Claude SDKs
1. Claude Agent SDK (README)
Evidence: E17
Date: Undated
2. Claude Agent SDK for TypeScript: Changelog
Evidence: E18–E27
Date: Undated; versions 0.3.292 to 0.3.319
3. Agent SDK reference — TypeScript
Evidence: E28–E37
Date: Undated
4. Claude Agent SDK for Python: Changelog
Evidence: E38–E40
Date: Undated; versions 0.2.126 to 0.2.160
5. SDKs, CLI, and libraries
Evidence: E41
Date: Undated
6. TypeScript SDK — Claude API documentation
Evidence: E42–E51
Date: Undated
7. Anthropic TypeScript SDK: Changelog
Evidence: E52–E61
Date: Entries dated 15 September to 5 November 2026
2. DeepSeek — Harness and SDK architecture
8. DeepSeek Harness (README)
Evidence: E62–E63
Date: Undated
9. sdk/ — drive a Harness runtime from another process
Evidence: E64–E66
Date: Undated
10. DeepSeek Harness Python SDK
Evidence: E67
Date: Undated
11. Agent Note: TypeScript SDK client and the SDK subagent backend
Evidence: E68–E72
Date: 27 July 2026; archived 4 September 2026
12. DeepSeek Harness Architecture
Evidence: E73–E74
Date: Undated
13. DeepSeek API Docs: Your First API Call
Evidence: E75
Date: Undated
3. Other TypeScript agent SDKs and toolkits
14. MCP TypeScript SDK (README)
Evidence: E76–E77
Date: Undated
15. OpenAI Agents SDK (JavaScript/TypeScript) (README)
Evidence: E78–E81
Date: Undated
16. AI SDK (Vercel) (README)
Evidence: E82–E87
Date: Undated
17. Mastra (README)
Evidence: E88–E90
Date: Undated
18. Agent Development Kit (ADK) for TypeScript (README)
Evidence: E91–E92
Date: Undated
4. TypeScript and Node.js — language and runtime
19. Announcing TypeScript 7.0 Beta
Evidence: E93–E95
Date: 21 April 2026
20. A 10x Faster TypeScript
Evidence: E96–E98
Date: 11 March 2025
21. Modules: TypeScript — Node.js documentation
Evidence: E99–E105
Date: Undated; type stripping marked stable in v25.2.0 and v24.12.0
5. Developer community and language adoption
22. Octoverse: A new developer joins GitHub every second as AI leads TypeScript to #1
Evidence: E106–E109
Date: 28 October 2025; updated 28 February 2026
23. Octoverse: Commits, pushes, reach new highs in 2026 as developers build with agents
Evidence: E110–E115
Date: 28 October 2026; updated 6 November 2026
24. Stack Overflow Developer Survey 2026: Technology
Evidence: E116–E117
Date: 2026 survey; no publication date on the page
6. Research papers — software quality and type-constrained code generation
25. To Type or Not to Type? A Systematic Comparison of the Software Quality of JavaScript and TypeScript Applications on GitHub — Bogner and Merkel
Evidence: E118–E127
Date: 2022; arXiv v1 of 21 March 2022
26. Type-Constrained Code Generation with Language Models — Mündler et al.
Evidence: E128
Date: 2025; submitted 12 April 2025, revised 8 May 2025
