R&D (LLMs & Rust)

Compensation: Equity

Exvisit is a hybrid cloud agentic IDE. A Rust daemon runs locally as a thin executor — file I/O, git, bash, symbol-graph queries — while a cloud reasoning engine runs the full agent loop and model calls over an encrypted connection. Files and credentials never leave the user's machine; the cloud only ever sees what it needs to reason about.

Our bet is that structural correctness has to be enforced, not hoped for. Every AI-proposed edit passes through a shadow compiler (compiled in the background before the user ever sees it), tree-sitter–based AST masking (blocking unsafe patterns like dynamic SQL construction), and a symbol graph that scores cross-file blast radius before a diff is ever shown for approval. Cloud reasoning is good at generating plausible code; we verify it locally, deterministically, before it hits disk.

This is an R&D-flavored engineering role at the intersection of systems programming and applied LLM work. You'll spend roughly equal time in two places: hardening the Rust daemon that does real work on real codebases, and iterating on the agent loop that decides what work to do. This isn't a "call the OpenAI API and wrap a UI" role — you'll be dealing with the messy reality of getting different model providers to reliably plan, call tools, and correct themselves inside a strict verification pipeline.

• Agent loop reliability — the ReAct-style loop that turns a user prompt into a sequence of tool calls, corrections, and a verified diff. Debugging cases where models hallucinate completion, fail to call tools, or emit malformed tool calls, and building the loop to self-correct instead of silently failing.
• Provider adapters — different model APIs disagree on how they stream tool calls, handle system messages, and shape function-call payloads. You'll build and maintain adapters that normalize these differences so the rest of the system doesn't need to care which model is behind it.
• The Rust daemon — extending the local executor: workspace tools, PTY-backed shell execution, git integration, and the symbol-graph queries that power cross-file awareness, all running with tight latency and safety guarantees.
• Structural verification layer — improving the shadow compiler's pre-write validation, extending AST-level masking rules (the S-expression-style rules that catch unsafe patterns), and refining how blast-radius scoring works across large codebases.
• Context & token management — context-window budgeting, auto-compaction strategies as conversations approach model limits, and live discovery of a provider's actual context window rather than hardcoding assumptions.
• Extensibility infrastructure — the MCP (Model Context Protocol) client layer and Skills system that let users bring their own tools and context into the agent.
• Cloud/local protocol — the websocket contract between the local daemon and the cloud reasoning brain: keeping it fast, well-tested, and resilient to partial failures.

• Strong Rust experience — you're comfortable with async, ownership/borrowing tradeoffs, and building reliable systems software (not just scripting in Rust)
• Real, hands-on experience with LLMs beyond calling a chat API — prompting strategies, tool/function-calling, agent loops, or evaluation of model outputs
• Comfort debugging distributed systems — you don't panic when a websocket connection drops mid-stream or a provider's SSE format doesn't match the spec
• A bias toward verification and correctness over "it looked fine when I tried it" — this matters a lot given what we're building
• Strong debugging instincts: reading logs, forming hypotheses, writing a test that proves the bug before fixing it

• Familiarity with parser/compiler concepts — tree-sitter, ASTs, or code-intelligence protocols (SCIP, LSIF, LSP)
• Experience with Tauri, or other Rust-based desktop app frameworks
• Contributions to open-source Rust projects, LLM tooling, or developer-tools infrastructure
• Experience with embeddings/vector search (e.g., ONNX runtimes, vector DBs) or running models locally (e.g., llama.cpp bindings)
• Opinions about what's wrong with today's AI coding tools — we'd like to hear them

You'd be working on a problem most AI coding tools haven't taken seriously yet: making agentic code generation safe by construction instead of safe by vibes. The verification pipeline is genuinely novel systems work, not a thin wrapper — and you'd be in early enough to shape how it evolves as we add more models, more languages, and more masking rules.

• Send us [resume / GitHub / relevant projects] to [[email protected]/application link — fill in]. If you've got a project, PR, or writeup that shows how you think about correctness or LLM tool-use, include it — we care more about that than a polished resume.