Questions

Venxuix is a Windows workspace that brings the creative applications you already use into one living VNX Workspace. Dccide is the kind of software it is: a Digital Content Creation Integrated Development Environment. It replaces nothing and connects everything you create with.

Decide. One product, one name in two parts, and the pun is the thesis: in Venxuix, the user decides how the workspace looks, behaves, and what it can do.

Venxuix is not an addon, it is the workspace that authors them. Its VNX Nerve Xtension is a split addon architecture: one extension panel is defined once and mounted twice, inside Venxuix and natively inside the host application, so Venxuix carries addons into Blender, Unreal Engine, Autodesk Maya, Houdini and other DCC applications rather than living inside any one of them.

No. It runs on Windows and works with it, not against it. What it adds is the layer Windows never filled: one place where applications, canvases and agents operate as one, on top of a fully customizable OS-managing base.

Nothing. That is the founding refusal. The applications creators already trust are the right applications, so Venxuix builds the world around them instead of substitutes for them.

There is no formal name for it yet, because it blends architectures that have never been blended this way: a DCC studio, an IDE, an agent harness and a workspace manager forged into one. That is why the name itself is the category.

One shared canvas rendered in two perspectives. The 2D perspective is an infinite plane where running applications appear as live cards. The 3D perspective renders the same canvas as dimensional space. Identical content, identical state, no duplication.

No, and that is the point. They are two viewpoints on one canvas. What you arrange in 2D is what you walk through in 3D, with nothing to sync and nothing to copy.

Yes. Every retargeted application appears on the 2D canvas as a live card, moving and real, so you preview, arrange and monitor your whole pipeline in one picture before full-screening any single tool.

Yes. The canvas is also a diagramming surface: screenshots, text and clipboard content drop straight onto it beside the live cards, then get annotated, connected and arranged into diagrams that document the work exactly where the work is happening.

Yes. The canvas is a launch surface as well: agentic orchestrations, VNX plugins and applications can all be raised directly from it.

A place, not a window layout. A workspace holds the tools, canvases and arrangement of one body of work, and you move between workspaces the way you move between rooms.

Workspaces behave like physical places: park one and it stays exactly as you left it, mount it again and you are back inside it. Nothing is rebuilt, nothing is rearranged, nothing is lost between sessions.

A saved bootstrapping configuration for an entire cross-application pipeline. Save the workflow once and the whole set of tools, canvases and arrangements reopens exactly as it was left, in one action, which is where the startup and navigation time between workflows goes.

It does not fight it. Instead of a strip of fourteen previews, one per application, Alt-Tab can show two Venxuix workspaces that together hold all fourteen apps inside. The switching problem is absorbed rather than replaced, and what you flip between is work, not windows.

The workspace switcher that lives beside the native one. Alt+Q cycles Venxuix workspaces, and the native switcher keeps doing its job untouched, so you gain a way to move through your work without losing the way Windows already moves through windows.

By automatic focus arbitration. The workspace elects a single keyboard owner at a time and hands focus over cleanly, so typing never lands in the wrong application.

The real native application runs inside the workspace, in its own customizable smart tab, at native speed. Nothing is emulated and nothing is a viewer: it is the actual software, full performance, in one window.

The desktop tools creative work actually crosses: 3D suites, game engines, video editors, code editors and browsers, with Blender, Unreal Engine, Autodesk Maya and Houdini among the DCC applications the extension layer is built around.

No. The application is the application. It runs natively at full speed, because retargeting hosts the real process rather than streaming or reimplementing it.

Yes, and it treats both worlds as one. On the web side, orchestrations call public HTTPS domains and REST APIs from inside the canvas. A single harness can hold a Windows application in one hand and a web API in the other, mixing both in the same workflow as if they were never separate.

The team structure behind the AI. An orchestration is a team of specialized agents raised against a surface: watchers that see, operators that act, verifiers that prove, each holding its own lane and together holding the whole workflow. One agency, many harnesses, any surface.

Yes. Any workflow you run, modeling, editing, coding or publishing, is a surface a custom orchestrative team can be raised against, shaped to your needs by watching and listening to how you actually work.

Yes, and that is the name being literal. The first agent team belongs to the VNX Canvas itself, so when you want a function that does not exist yet, the same agents that build and maintain the system help author and execute it for you.

They act inside it. Screen-aware agents read the workspace and operate its tools through the same retargeted application tabs and canvases you use, which is the difference between an assistant that describes the work and one that does it.

Where they grow up. They are raised on live, visual, moving creative work, the hardest thing software knows, and they see the screen and act on it rather than guessing from text. Understanding was never what models lacked. Seeing and doing were.

Yes, through the eval channel and the live streaming layer, pixel by pixel. That is how a model can visually check the code it just wired against what is actually on screen instead of trusting a return value.

The harness's ground-truth line into the running workspace. Through it an agent reads real state, executes operations, and verifies that what it changed actually changed, in the software itself rather than in its own assumptions.

Yes, it is open by design. Any model, from any IDE, can connect to test the code it just wired, and an orchestration of agents can verify that work against the running workspace, with iteration and further customization inlined in the same loop.

Verifiers are a lane of their own. A change is not finished when it is written, it is finished when the workspace shows the state actually changed, seen through the eval channel and confirmed with the model's own eyes.

The workspace's eyes. Your screen streams directly to an LLM of your choice so the agents interpret the work as it happens, rather than being told about it afterwards.

Yes, and the structure is deliberate: one live session, one stream per monitor, every stream time-aligned into the same take. Monitor count is a configuration decision, not an architectural limit, and the model reads all of them together as one continuous picture of the work.

Bring your own key. Every LLM key belongs to you, the workspace supplies the workspace and never the entitlements, and you choose which model sees your work.

Speak and the workspace listens. You verbally architect what you want and it carries it out, while everything said during the work is transcribed as it is spoken.

It becomes structure. Words are separated cleanly from the audio and time-aligned to the moment they were said, interval by interval, so a reading model knows not just what was said but exactly when in the work it was said. An optional agentic layer reads the transcription as it lands, distilling intent in real time.

Draw and annotate over any running application, with the markup living above the tools rather than inside any one of them. Like your voice, every stroke belongs to the moment it was made and is recorded as a stream of the session.

Screen, voice and ink captured together as one living take. The work becomes machine-readable: frames, text renderings and transcripts an agent can read and act on.

Any moment in it can be revisited directly, not just replayed from the start. Speak while you draw while you work, and the take holds all three, aligned, for you or an agent to return to.

Yes. A take can be turned into instructions, evidence or a work order, which is how something you said mid-work becomes something an agent executes later.

The portable extension shell. One extension panel is defined once and mounted twice, inside the Venxuix workspace and natively inside the host application, speaking over one command channel, so exact commands, logic and data move between the workspace and the software. The addon stops being something you operate inside one program and becomes a payload Venxuix carries.

XUIX, the Xtended User Interface Xperience, is the face of that shell. The same panel that controls the workspace is the panel waiting inside your creative software, so you never re-learn the room, you carry it.

The scholar of the extension layer. It studies each host software's installed addons and writes per-addon analysis and usage knowledge, rendered as a navigable graph with Analysis, usage RAG and Xtension Blueprint views, so you and the agents know what an extension can do before it is driven.

That is exactly what Agent Xtension exists for. Nothing is driven before it is understood: the analysis and usage knowledge are written first, so an agent reaching for an extension already knows what it does.

Only. Venxuix uses the extension surfaces each vendor natively publishes for exactly this purpose, scripting and code editors, plugins, published APIs and MCPs, used as released, inside software you have already licensed.

That is where this leads. Every workflow you shape becomes a real, holdable thing, a blueprint of how your workspace runs, and blueprints can be handed on. Workflow blueprints and purpose-curated UI and OS managers are a shelf of technology waiting to exist, the way presets and addons are sold today, except what changes hands is a whole working household.

An LGPL license is the plan for the core, inside a multi-split architecture: components licensed lane by lane, MIT, GPL, LGPL or proprietary, combined by design. Every hosted application keeps its own vendor's license, in full effect.

Because architectures woven this tightly do not survive being handed out and hoped over. It arrives as a tended ecosystem with every pillar held apart, so the ground stays standing under a million different ways of deciding.

Bring your own license. Every retargeted application arrives under a license you already own, and retargeting begins only where a valid license already exists.

No. It does not reverse engineer, decompile or disassemble them, does not modify, patch or inject code into their binaries or memory, does not circumvent license enforcement, does not redistribute or bundle them, and does not access interfaces a vendor has not published. It builds around licensings, never inside them.

Not yet. It is built and running as a living workspace today, with a demo series coming first, then a moderated release. The contact page carries the official channels to follow it.