blog.vims
← All articles

Build Anything: SDK, Coder, Terminal

Part 13 of the [VIMS Blog Network](00-vims-convergence-point). VIMS is a platform for building AI-native applications.

Part 13 of the VIMS Blog Network. VIMS is a platform for building AI-native applications.

The Platform Problem

You want to build a real AI-native application that uses agents for reasoning, P2P for connectivity, voice for interaction, and payments for monetization. What do you need?

You need an agent runtime. You need P2P connectivity. You need a voice pipeline. You need a payment layer. You need a knowledge base. You need a database connector. You need a UI framework that integrates with all of the above. And you need to ship it as a deployable application.

If you are building on a traditional agent framework, you assemble all of these from separate libraries, write the integration code, and maintain it. Every update to any component breaks the integration. Every new capability requires new integration work. The platform does not help you: it gives you an LLM API and wishes you luck.

VIMS is different. It is a platform (an operating system layer with an SDK, a built-in IDE, and a terminal) designed for building AI-native applications that leverage the full stack: agents, P2P, voice, payments, knowledge, databases, flows, and teams.

The VIMS SDK

The SDK is how you build on top of VIMS. It provides the interfaces, hooks, and components that connect your app to the operating system.

App and Module Templates

VIMS ships with templates for two types of buildable artifacts:

  • Apps: full-window applications that render as a top-level surface in VIMS. An app has its own route, its own window, and its own lifecycle. Examples: a customer support dashboard, a research portal, a project management tool.
  • Modules: inline components that render within other surfaces. A module can be embedded in a team room, a meeting panel, or a knowledge base view. Examples: a kanban card widget, a meeting timer, a database query result card.

Templates include the boilerplate: manifest schema, entry point, permission declarations, and capability requirements. You start from a template, not from a blank file.

The React Provider

VIMS SDK apps are built with React. The SDK provides a React provider that injects VIMS capabilities into your component tree:

  • Agent instances: start, stop, chat with, and manage agent instances from your app
  • P2P surfaces: join team rooms, access shared drives, query shared databases
  • Meeting integration: add agents to meetings, inject audio, manage peers (Blog 07: Voice and Meeting Agents)
  • MCP connectors: invoke MCP tools from your app via the useMCP hook (Blog 05: MCP Connectors)
  • Knowledge base: search, index, and manage KB documents (Blog 04: Data and Knowledge)
  • Flows: create, run, and monitor flows from your app (Blog 11: Flow and Teams)
  • Channels: send messages through configured channels (Slack, Discord, email, SMS, Telegram)

The provider is transport-free: it does not know whether it is running on desktop or browser. The desktop injects native transport; the browser injects sidecar relay transport. Your app code is the same either way. (Blog 06: P2P Surfaces)

Tool Registration API

Your app can register custom tools that agents can use. A tool is a named function with a schema: the agent sees the tool name, description, and parameter schema, and can invoke it during reasoning.

For example, a customer support app might register a lookup_customer tool that queries the app's database. When an agent in the app receives a support request, it can call lookup_customer to retrieve the customer's history before responding.

Registered tools are governed by the same security model as built-in tools: HITL gates, per-agent policies, audit trails. Your app's tools extend the governed toolset. (Blog 03: Security First)

Window Rendering Contract

Apps declare how they want to be rendered:

  • Full-window mode: the app takes over the entire VIMS window. It is the primary surface. Examples: a database dashboard, a knowledge base explorer.
  • Inline mode: the app renders within a container inside another surface. It is a component, not a full page. Examples: a kanban widget inside a team room, a query result inside a knowledge base view.

The rendering mode is declared in the app manifest. VIMS uses it to determine how to route to the app and how to allocate screen space.

ExtendedHooks

The SDK exposes ExtendedHooks: React hooks that provide access to advanced VIMS capabilities:

  • MeetingAddAgent: add an agent to a meeting room from your app
  • TeamRoom: join and interact with a team room from your app
  • FlowRun: trigger and monitor flows from your app
  • KBSearch: semantic search over the knowledge base from your app
  • DBQuery: execute SQL against connected databases from your app

ExtendedHooks are the bridge between the SDK's React provider and VIMS's deeper capabilities. They let your app leverage the full OS without needing to understand the internal architecture.

Coder: The Built-in IDE

VIMS includes a built-in IDE called Coder. It is a surface within VIMS, designed for building VIMS apps and modules.

Monaco Editor

Coder uses the Monaco editor: the same editor that powers VS Code. It provides syntax highlighting, code completion, multi-cursor editing, split views, and all the editing capabilities you expect from a modern IDE.

AI-Assisted Code Generation

Coder's AI assistant uses the configured LLM provider (your local vLLM or Ollama instance) for code generation. You describe what you want in natural language, and the assistant generates code. Because it uses the local LLM, there is no per-token cost and no data leaving your machine. (Blog 01: Local-First AI)

The assistant is context-aware: it sees your project structure, your open files, and your existing code. It can generate new files, modify existing ones, and suggest refactorings.

Git Integration

Coder includes full git integration: file explorer with git status, stage/unstage, commit, branch management, and diff viewing. You can manage your entire git workflow from within VIMS without switching to a terminal.

File Explorer and Terminal

The file explorer shows your project structure with file types, sizes, and modification times. The integrated terminal lets you run commands (build, test, deploy) without leaving the IDE.

The Terminal Tool

VIMS includes a Terminal tool that manages shell processes. It is a process registry that supports multiple environments:

  • Local: run commands on your host machine
  • Docker: run commands inside a Docker container
  • SSH: run commands on a remote server via SSH
  • Modal: run commands in a Modal cloud sandbox
  • Daytona: run commands in a Daytona workspace

Each environment is registered as a process backend. You can start a process in one environment, monitor its output, and stop it, all from the Terminal tool. Multiple processes can run concurrently, each in its own environment.

The Terminal tool is agent-accessible. An agent can start a process, read its output, and stop it, governed by HITL gates and per-agent security policies. This is how agents run tests, execute builds, and perform DevOps tasks within the governed security model.

Building a P2P App

To show how the SDK comes together, here is what it looks like to build a P2P app that joins a meeting, queries the knowledge base, and dispatches tasks across agent instances:

  1. Create an app from the template: vims create app my-app
  2. Configure the manifest: declare permissions (meeting access, KB search, agent dispatch) and capabilities (P2P, voice)
  3. Use the React provider: wrap your component tree with the VIMS provider, injecting the transport (native for desktop, sidecar for browser)
  4. Add the MeetingAddAgent hook: use the ExtendedHook to add an agent to a meeting room when the user clicks "join"
  5. Add the KBSearch hook: use the ExtendedHook to search the knowledge base and display results
  6. Add the agent dispatch API: use the provider's agent API to dispatch tasks to agent instances and display results
  7. Register custom tools: if the app has domain-specific tools (e.g., lookup_customer), register them so agents can use them
  8. Test in Coder: use the built-in IDE to run, debug, and iterate
  9. Publish to the app marketplace: package the app and publish it for others to install (Blog 13: App Marketplace)

The entire workflow happens inside VIMS. No external tools, no separate SDK download, no configuration files pointing to remote services. The platform is the development environment.

The Security Inheritance

SDK apps do not get a security bypass. They inherit the full VIMS security model:

  • HITL gates: if an app's agent tries to execute a high-risk tool, the approval gate fires
  • Per-agent policies: the agent instance running inside the app is governed by its security policy
  • Audit trails: every action taken by an app's agent is logged with correlation IDs
  • Sandboxing: if the agent instance is sandboxed, the app's agent actions are sandboxed too

This means you can build apps that use agents without worrying about the security implications. The OS layer handles governance; you focus on the app logic. (Blog 03: Security First)

The Publishing Path

Finished SDK apps are published to the app marketplace. The publishing flow:

  1. Package the app: the manifest, source code, and assets are bundled
  2. Compatibility check: VIMS verifies the app is compatible with the target VIMS version
  3. Publish: the app is listed in the marketplace, discoverable by other VIMS users
  4. Install: other users install the app on their VIMS instance with one click
  5. Update: when you publish a new version, installed instances can update

The app marketplace completes the platform loop: build with the SDK → publish to the marketplace → install on any VIMS instance → compose with agents, flows, and teams. (Blog 13: App Marketplace)

The Platform Contract

The VIMS SDK, Coder, and Terminal together form a platform contract:

  1. Everything is an app. Surfaces, tools, integrations; all are buildable with the SDK.
  2. The platform provides the primitives. Agents, P2P, voice, payments, knowledge, databases, flows, teams; you compose them, you do not build them.
  3. Security is inherited. Your app gets the full governance model for free.
  4. Transport is injected. Your app code works on desktop and browser without changes.
  5. Distribution is built-in. Publish to the marketplace; install on any instance.

VIMS is the platform for building AI-native applications: the last piece of software you install.

Previous: Flow and Teams Next: The App Marketplace