Your code. Your agent.
Your flow.

Vyne is an agentic AI coding environment that understands your codebase, plans the work, modifies files, and runs the tools — while you stay in control.

not released yet — downloads land here first

vyne — your-project
theme.ts session.ts
1// theme pair, wired to the system setting
2import { createTheme } from "@ui/theme"
3 
4const light = createTheme({ bg: "#ffffff" })
5const dark  = createTheme({ bg: "#0e1117" })
6 
7configureScheme(light, dark)
8await applyTheme(system())
session.tsTypeScript
−const session = getSession()
+const session = await getSession()
 if (!session) redirect("/login")
✓ 1 file changed · 18 tests passed
bash — your-project
$ npm test
… running test suite …
✓ 18 passed · 0 failed (2.4s)
$ â–‹
main session.ts · UTF-8 18 tests passed model: qwen2.5-coder:14b local

A seed. Then Vyne.

Every word of Vyne is grown — context, planning, tools, changes, verification. Drag the handle, or press grow.

V y n e

Built around the agent, not the autocomplete.

Vyne works with the whole project — reading the code, planning the change, using tools, and inspecting results before it calls the task done.

dashboard.tspredicts the next line
1const user = getUser()
2const settings = getUserSettings(
3user.id)
keeps typing — never sees the task
task: add dark modeunderstands the task
✓ reads the project
→ plans the change
→ edits the files
→ runs the tests
✓ 18 tests passed
investigates, changes, verifies — then reports
You
describe it
a bug, feature, or idea
→
Vyne
plans
reads the relevant code
→
Tools
act
edit, search, run
→
Codebase
changes
precise, reviewable diffs
→
Results
verified
you stay in control

Four steps. You drive.

Each stage is visible in the app as it happens.

01
Tell Vyne what you want
Describe a feature, bug, refactor, or idea in plain language.
02
Vyne explores
It reads the relevant parts of your project and forms a plan.
03
Vyne builds
Files get modified and tools run — each step visible to you.
04
You review
Inspect the changes, results, and output before anything sticks.

One task, step by step.

The full timeline, exactly as it runs in the app.

vyne agentworking
analyzing project…
✓ Read package.json
✓ Read src/auth/session.ts
✓ Read src/middleware/auth.ts
planning changes…
✓ Authentication flow identified
editing…
→ src/auth/session.ts
testing…
→ npm test
✓ 18 tests passed · 0 failed
task complete

Built for real projects.

Every card below is a slice of the actual app.

Understands your codebase

Looks at the files that matter before touching anything.

Searching project…
✓ src/
✓ components/
✓ hooks/
→ Relevant files found
Plans before it changes

Reasons through steps instead of guessing.

PLAN
01 Inspect auth
02 Update session
03 Update callers
04 Run tests
Works with your tools

Talks to the project itself, not just a file.

read edit search terminal git
Verifies the result

Runs checks and looks at the output.

Tests
18 passed · 0 failed
Reviewable diffs

Every edit lands as a diff you can read.

−const session = getSession()
+const session = await getSession()
You stay in control

Significant actions wait for your call.

Vyne wants to run:
$ npm test
[deny] [allow]

Every edit, as a diff.

The session helper called a sync API that's now async. Vyne made the change and updated the callers — one file, verified with tests.
session.ts TypeScript 1 file changed +1 −1
−3// get the session for this request
−4const session = getSession()
+4const session = await getSession()
 5 
+6// callers updated to await the async API
 7if (!session) redirect("/login")
 8return session
 9}
+10// tests updated: 3 new cases

Agentic doesn't mean unchecked.

Vyne asks before it touches anything significant. This is what that looks like:

vyne wants to run
$ npm test
vyne wants to edit
src/auth/session.ts
Review changes
Every edit is a diff before and after it's applied.
Approve actions
Commands and file writes wait for your go-ahead.
Stop anytime
One stop button halts the agent mid-task.
Control access
You choose the project, model, and tools.

Your code stays close.

Vyne runs entirely on your machine — model included, through Ollama. We won't sell you a magic security promise; the architecture simply means your code doesn't have to leave your hardware.

your machine
where everything runs
→
vyne
the agent
→
local model
via Ollama
→
your project
read · edit · run
works offline no cloud account history stays local

Join the Vyne community.

Talk with other developers, share what you've built, get help with Vyne, suggest features, report issues, and follow development updates.

Built in the open.

Read the docs, watch the repo, and be ready for the first release.

downloads land here when the first release is ready — no fake installers