yycore.ai

Private V0 prototype not available for download

The agent drives the IDE. You hold the keys.

YY IDE is an agent-operated development environment built around human governance: the agent carries the work while you supply intent, judgment, approvals, and credentials.

See the real interface Read the build notes

Active private development. The interface capture uses deterministic fixture data inside the working V0 UI. No public build, release date, price, or waitlist is being announced.

YY IDE Develop view showing file navigation, a floating terminal, lifecycle controls, a code change, agent conversation, adversarial review, and a visible write approval.
Working V0 interface · deterministic fixture state

Current interface captures

The working UI, not a website reconstruction

These images were captured at the desktop app's 1280 × 720 window size from the React interface used by YY's Tauri V0. They use deterministic fixture data so the states are reviewable; they are not a fabricated website mockup or a public release.

YY IDE Spec view showing a requirement ledger, acceptance checks, active work, and lifecycle navigation.
SpecRequirements and acceptance checks remain live working state, not a document the implementation leaves behind.
YY IDE Deploy view showing build, test, package, signing, artifact, and release gates.
DeployPackaging, signing, artifacts, and release gates remain inside the same agent-operated lifecycle.

Implemented V0 scope

A working vertical slice, not a launch announcement

The prototype already exercises the architecture from desktop UI through the Rust runtime. These are implementation facts, not availability or maturity claims.

  • Tauri desktop shell and project boot flow
  • Typed event, component, and capability foundations in Rust
  • Streaming agent loop with a bring-your-own-key model path
  • Editor read and write tools with approval enforcement
  • Filesystem navigation and live terminal execution
  • Orientation tools and middleware hooks around agent work
  • Design, spec, develop, and deploy lifecycle views

The human role

The agent operates. You decide.

This is not hands-off theater. Sustained execution belongs to the agent; consequential judgment stays with the human.

  • Intent

    Describe the outcome and the constraints that matter. The agent turns that direction into concrete development work.

  • Judgment

    Resolve real ambiguity, review tradeoffs, and decide whether the result is useful - not how to type every edit.

  • Approvals

    Consequential actions surface visibly. Routine execution stays with the agent; irreversible decisions stay with you.

  • Credentials

    Secrets and identity remain human-controlled inputs instead of ambient context for an autonomous loop.

Component contract

Events, tools, middleware

YY treats its own surfaces as capability sources. The editor, terminal, review system, and future components share one explicit contract instead of becoming separate agent integrations.

events

A shared record of what happened

Editor, terminal, review, and agent activity project from typed events instead of hiding work behind disconnected panels.

tools

Every surface can become a capability

Components expose bounded operations through one tool interface, so the agent can act without guessing how the IDE is wired.

middleware

Checks travel with the workflow

Diagnostics, review, limits, and context shaping can wrap the agent loop at the component boundary.

Current boundary

What this preview does not claim

Private, early, and still changing.

There is no public build, release date, price, compatibility matrix, benchmark result, or claim that YY replaces a mature general-purpose editor today. This page exists to show the direction, the working scope, and the boundary between them.

Explore released YY work Read Engineering Notes