This roadmap does not represent a guarantee that the features and products will be delivered on the specified dates as described in this document. The delivery dates may change, and features may be added or removed at any time. It is merely an outline of our thoughts for the future, and is subject to change at our discretion.

App Mode (December 2025)

The release of App Studio marks the beginning of a new era. We have moved the entire development lifecycle into the browser, embedding the tools directly into your running application. We call this App Mode.

The Visual Builder: App Mode eliminates the "Alt-Tab" tax. You no longer switch between a designer and a browser window. You are always in the application.
Live Inspection: Activate the inspector and click on any element in your live app such as a grid, a field, or a button. The App Explorer instantly synchronizes to that specific node in the configuration hierarchy, allowing you to make surgical changes with zero searching.
Instant Feedback: Change a label, drag a field to a new category, or apply a validator. The application refreshes instantly, keeping you in the "flow state" of development.
The "Glass Box": App Mode doesn't just show you the UI; it shows you the structure behind it. By exposing the Data Controllers and Page definitions in the App Explorer, we provide the structured metadata (the "Invisible UI") that our Digital Workforce relies on to understand and manipulate your application.

App Mode is the default state for the modern Code On Time developer: a unified, zero-latency environment where the line between "using" and "building" disappears.

v9 (January 2026)

In January 2026, we will reach the destination of the journey we began with the first release of App Studio. Code On Time v9 marks the completion of our migration from a Windows-based utility to a fully browser-native development environment.

With this release, the entire application lifecycle (from defining data structures to deploying binaries) is consolidated into the App Studio. We are retiring the context switching of the past. Whether you are modeling complex SQL relationships, writing C# business logic, or pushing a release to Azure, you will do it all within a unified, zero-latency interface running directly inside your application.

This milestone delivers the three final pillars required to replace the legacy Project Designer completely: Data & Models, Workspace Mode, and App Deployment.

Data and Models

In January 2026, we are introducing a Unified Data Modeling Workflow that fundamentally changes how you define applications. Historically, Code On Time treated SQL databases as the primary citizen and APIs as external integrations. That distinction ends now.

We are introducing two new dedicated hierarchies in the App Explorer: Data and Models.

The "Data" Hierarchy: This is the anchor for all your data connections. Here, you define not just SQL connections (Oracle, SQL Server), but also API Data Sources like SharePoint, Google Drive, or custom REST services.
The "Models" Hierarchy: This is your design-time library. Whether a model represents a physical SQL table or a virtual API resource, it lives here as a standardized *.model.xml blueprint.
First-Class APIs: You can now add an API Entity alongside your SQL tables. The framework treats them identically. You define the "contract" (endpoints), and the AI Co-Worker can automatically discover the schema by analyzing raw JSON responses, mapping complex structures to flat columns.
The "Pending" Workflow: To bridge the gap between design and runtime, we are introducing a "Pending" state. When you define a new model, the live app will "freeze," visually guiding you to click the Generate trigger. This ensures your runtime application is always perfectly synchronized with your data definitions.

This unified mental model reduces cognitive load, allowing you to build apps on top of any data source using the exact same tools.

Workspace Mode

Release 8.9.46.0 introduced App Mode, allowing you to edit a running application live. But real-world development isn't always a "happy path." Sometimes, you break the app. Sometimes, you need to perform deep architectural surgery that renders the runtime temporarily unstable.

In January 2026, we will deliver Workspace Mode - the "Safe Haven" for deep work.

The Logic Lab: Unlike the live App Mode, Workspace Mode decouples the development environment from your running application. It runs as a separate, stable web app on your local machine.
Permanent Context: Say goodbye to modal popups that block your view. In Workspace Mode, the App Explorer and Business Rules open as permanent tabs that remain open until you close them. You can keep a business rule open alongside your data controller hierarchy, switching context instantly.
Revive the Broken: If your application fails to compile or start, App Mode cannot help you. Workspace Mode is designed to run independently, giving you full access to your configuration tools even when the "product" is broken.

With the arrival of Workspace Mode, we will mark the transition to Code On Time v9.0.0.0, officially retiring the legacy Windows-based Project Designer.

App Deployment

Managing your application's deployment is now a seamless, unified experience within the App Studio. Whether you are in "App Mode" (Live) or "Workspace Mode," the dedicated Deployment hierarchy is just one click away via the "Deploy" button in the main toolbar.

Unified Access: In the live app, the deployment hierarchy appears in a docked instance for immediate access. In Workspace Mode, it acts as a dedicated tab within the App Explorer, ensuring your release configurations are always available alongside your code.
Diverse Targets: The Deployment hierarchy organizes your publishing targets into a clear, logical structure. Native support includes File System, FTP/FTPS, and Microsoft Azure App Service (including slots), with architecture in place for future providers like AWS.
Simple Workflow: Deploying is intuitive. Simply select your target node in the hierarchy and click "Deploy." The App Studio handles the build, packaging, and transfer process automatically.

This centralized approach eliminates the complexity of release management. By providing a focused interface for defining and executing deployment configurations directly within the studio, we have streamlined the path from localhost to production.

24/7 Multilingual Help Desk (February 2026)

The previous roadmap promised an "Assistant" and a traditional "Community Help Desk". We have aimed higher. Instead of a passive help tool, we are deploying a Digital Workforce.

Arriving in February 2026, the Tutor and Builder will replace the "Assistant" as your primary support interface.

The Tutor (Free 24/7 Support): Powered by the exact metadata of your specific Code On Time version, the Tutor provides instant, hallucination-free answers to "How-To" questions in any language. It knows precisely which features are available in your installed version, something no human agent could track perfectly.
The Builder (Active Assistance): For project-specific tasks, the Builder consumes credits to analyze your unique project structure and generate executable instructions.
Why the Pivot? We realized that a static forum or help desk ticket system is too slow for modern development. By embedding the support intelligence directly into the studio, we eliminate the wait time entirely.

Scribe Mode (April 2026)

To complete the development lifecycle, we are introducing the final persona in the App Studio: The Listener.

While the Builder expects precise commands, real-world requirements often emerge from messy, unstructured conversations. Scribe Mode acts as a "Prompt Compiler," allowing you to build software at the speed of conversation.

The "Prompt for Builder": The Scribe listens to your voice (via Web Speech API) or accepts your stream-of-consciousness typing. It filters out the noise and summarizes your intent into a precise, machine-readable Builder Prompt. It is not a meeting note-taker; it is a requirements distiller.
The Clarity Gauge: As you speak, the Scribe generates an Ephemeral Cheat Sheet in real-time. This acts as a visual feedback loop. If the Cheat Sheet accurately reflects the feature you want, you know the AI has "understood" the room. If it looks wrong, you simply keep talking or type a "Director's Note" to correct it.

Stimulus for Discussion: When the conversation pauses, the Cheat Sheet stabilizes. You click "Apply All" to materialize the changes instantly. This shifts the meeting from "talking about requirements" to "reacting to the working software," stimulating a deeper and more valuable feedback loop with your stakeholders.

The Scribe makes the "Digital Consultant in a Box" a reality, allowing you to walk out of a meeting with a working prototype based purely on the discussion that just happened.

KB (Knowledge Base) (April 2026)

Support shouldn't be a black hole; it should be a learning loop. In April 2026, we are introducing a new Closed-Loop Support System powered by the Content Hub.

The Escalation Flow: If the Tutor or Builder cannot solve your problem, you can "Escalate" the conversation directly from the prompt. This captures the full context (your prompt, the error state, and the metadata) and converts it into a support ticket.
The Co-Worker Triage: Our internal AI Co-Workers will analyze incoming tickets immediately, checking our internal knowledge stores to see if a solution already exists.
From Ticket to Wisdom: When a new issue is resolved by our human engineers, the solution isn't just emailed back to you. It is published to our new Public Knowledge Base (/kb).
Continuous Learning: Once published to the KB, the Tutor immediately indexes the new article. This means the next developer who encounters the same issue gets the correct answer instantly. Every support ticket you file makes the platform smarter for everyone.

Digital Workforce Platform (May 2026)

In May 2026, Code On Time delivers its most significant evolution yet. We are moving beyond "building apps for humans" to providing a complete Digital Workforce Platform embedded directly into the applications you create.

This is not a single feature; it is a unified ecosystem comprising four distinct faces that work together to bring AI Co-Workers into your enterprise.

API Mode

Building for the Digital Workforce requires seeing the world through their eyes. In March 2026, we are introducing API Mode, a dedicated interface for the AI Architect.

The Agent's View: When you switch to API Mode, the familiar grids and forms disappear. In their place, the App Studio renders a live, interactive "Documentation View" of your HATEOAS resources. This is exactly how an AI Agent perceives your application.
Visualizing the State Machine: Instead of guessing what actions are available to the AI, you see them. The HATEOAS links (e.g., rel: "approve", rel: "cancel") are rendered as clickable actions, allowing you to traverse the application state just like a Digital Co-Worker.
Live Debugging: If a link is missing, you know immediately that a security rule or business logic filter has hidden it. You can inspect the API documentation and click on any resource link to instantly locate its definition in the App Explorer.
Zero-Code Interaction: API Mode allows you to test complex transactions without writing scripts. You can follow POST and PATCH links directly from the documentation view with auto-complete support for JSON bodies.

Co-Worker

Your application is no longer just for humans. In May 2026, we will unlock the Digital Co-Worker, a secure, autonomous agent embedded directly into your runtime application.

The Operator: While the Tutor explains how to use the app, the Co-Worker actually does the work. It operates the "Invisible UI" (the HATEOAS API) of your application, navigating data and executing tasks at machine speed.
Identity Inheritance: Security is not an afterthought. The Co-Worker runs as the user. If a user asks it to "Approve all pending orders," the Co-Worker can only see and approve the orders that the user's specific role and SACR (Static Access Control Rules) permit. It cannot bypass your business logic.
Conversational Reporting: The Co-Worker effectively replaces the need for complex, static report builders. Users can simply ask, "Show me the top 5 suppliers by volume this quarter," and the agent queries the live data to present the answer instantly.
The "Headless" Advantage: Because the Co-Worker operates on the API, it can also function "headlessly" via email or SMS (using the Device Authorization Flow), allowing your human workforce to interact with your database securely from anywhere without opening a browser.
The State Machine: The Co-Worker is backed by a persistent Axiom State Machine. It handles "Interactive" conversations that move at your speed, and "Async" tasks that run in the background. It even intelligently manages "abandoned" tasks, ensuring that no request is ever lost, even if you close the browser.
Transparent Reasoning: The Co-Worker doesn't just act; it thinks. In interactive mode, it streams its decision-making process (e.g., "Checking inventory levels for product X...") in real-time, keeping you in the loop and building trust in its actions.

Every Code On Time application comes with 100 Free Digital Co-Workers. You simply bring your own LLM key (BYOK), ensuring that your sensitive runtime data never passes through our servers.

Dynamic Data Collection

This feature fulfills the vision originally described as "Data-Driven Surveys" in previous roadmaps, but evolved to match the power of the Digital Workforce.

In the real world, business requirements often change faster than software release cycles. New safety regulations, updated compliance checklists, or emergency field reports cannot wait for a developer to add columns, recompile, and redeploy the application.

Dynamic Data Collection solves this by allowing your application to define new data structures at runtime.

The Runtime Builder: We have adapted the App Explorer (the same tool developers use to build the app) to run inside the live application. Business users can use a simplified version of this tool to visually design complex forms (Audits, Inspections, Questionnaires) with drag-and-drop ease.
The Co-Worker as Architect: You don't even need to design the form yourself. Simply prompt your Digital Co-Worker: "Create a daily fire safety inspection checklist for our warehouse." The Agent utilizes the Axiom Engine to generate the complete JSON definition instantly, applying best practices for data types and layout.
Offline by Default: This feature is the "Killer App" for our Offline Sync technology. Because the survey definition is stored as data (not code), it synchronizes instantly to thousands of devices. A field worker (e.g., a nurse or inspector) can download a new audit type in the morning, drive to a location with no signal, collecting structured data, and sync it back when they return.
Structured Storage: Unlike simple "Form Builders" that trap data in proprietary silos, Code On Time stores the definition and the response in your own SQL tables (e.g., Surveys and Audits). You can even instruct your Co-Worker to parse incoming audit results and route specific data points into your core business tables automatically.

This transforms your application from a static tool into a Rapid Process Materialization Engine, allowing you to deploy new business processes to the edge of your network in minutes, not months.

Workflow Tasks and “Interactive” Links

The original roadmap introduced "Workflow Links" as a way to send actionable URLs via email. In the era of the Digital Workforce, we are expanding this concept to bridge the gap between human users and AI Agents.

In May 2026, we will introduce a unified "Interactive" Task Engine.

For Humans (Workflow Tasks): You can now attach a "Workflow Task" definition directly to any Email or SMS business rule. Instead of asking users to navigate complex menus, the system generates a secure, "single-purpose" link (e.g., /tasks/approve-order/94e19bc3-59e6-4195) that takes them directly to a focused form to perform a specific action.
For Agents (Interactive Links): The Axiom Engine automatically injects these same tasks into the API as interactive hypermedia controls. When an AI Co-Worker encounters a permission block or complex decision, it uses this link to "hand off" the task to a human, presenting the exact same "Reduced UI" form.
The "Transactional Outbox": Notifications are no longer fire-and-forget. They are transactional (and auditable) records. If a user clicks a link to approve an order that has already been approved, the system intelligently shows the receipt instead of the form, ensuring data integrity.

This unified architecture allows you to design a single business process that serves both your human workforce (via Email/SMS) and your digital workforce (via API hand-offs) simultaneously.

Headless Agent Hosts

The original roadmap envisioned "Serverless Apps" primarily as a mechanism for distributing offline-capable front-ends. While offline synchronization remains a core capability, we have redefined this deployment model to prioritize intelligence.

In May 2026, we are introducing Headless Agent Hosts.

This deployment model allows you to strip away the visual overhead of the web application, deploying your backend (the Axiom Engine and HATEOAS API) strictly as the "Brain" for your AI Co-Workers.

The Micro-Ontology Factory: When deployed as a Headless Host, your application functions as a distinct Micro-Ontology for the enterprise. Instead of dumping all data into a massive, insecure data lake, you wrap specific domains (e.g., HR, Inventory) in their own secure, self-describing API shells.
Active Logic & Control: Unlike passive knowledge graphs, a Headless Host enforces business rules and security (ACLs) in real-time. It tells the Agent not just what the data is, but what actions are valid, preventing the AI from ever hallucinating an unauthorized transaction.
The Knowledge Mesh: Using Federated Identity Management (FIM), you can link these hosts together. A Co-Worker can "consult" the Inventory Ontology to check stock levels while conversing with a customer in the Sales Ontology, maintaining strict security boundaries the entire time.
Talk to Your Data: You can choose to disable the standard user interface entirely. In its place, users are presented with a simple, secure, ChatGPT-style prompt. This transforms your complex database application into a conversational intelligence engine, where users simply ask questions and command actions.
The Ultimate Backend: For developers who prefer custom front-ends (React, Angular, Vue), the Headless Host serves as a robust, secure backend. Your custom UI consumes the same self-describing HATEOAS API that powers the Co-Worker, inheriting all the business logic and security rules (SACR) defined in the App Studio.
Omnichannel Reach: Configure hooks for services like Twilio or SendGrid to allow your workforce to query this ontology and trigger workflows via SMS Text and Email, engaging with the "Brain" directly without ever loading a UI.
Hybrid UI Access: You can configure the application to be "Headless by Default" while preserving the "Visible UI" (grids and forms) for specific power users. For example, System Administrators can access the full management interface to perform deep data maintenance, while the majority of the workforce interacts exclusively through the streamlined Co-Worker via chat, text, or email.

This architecture ensures that your application is not just a screen for humans, but a ubiquitous intelligence service available wherever your business operates.

Database Builder

The original roadmap envisioned a visual diagramming tool for schema management. However, in the era of the Digital Workforce, dragging boxes on a screen is too slow.

We are redefining the Database Builder not as a separate visual tool, but as a core capability of the App Studio powered by the Builder.

Conversational Schema Design: Instead of manually defining columns and foreign keys, you can simply ask the Builder: "Add an inventory management module to my database."
The Cheat Sheet: The Builder analyzes your existing schema and presents a structured Cheat Sheet containing the precise SQL CREATE TABLE and ALTER TABLE statements required. These are presented as executable code blocks, giving you full visibility into the proposed changes.
Controlled Execution: You can review the code and click "Apply All" to execute the statements immediately against your Default Database or any specific auxiliary SQL Data Source. Alternatively, you can copy the code and execute it manually via the new SQL console actions available on every data source node in the Data hierarchy.
Instant Prototyping: Need sample data? Just ask. The Builder can populate your new or existing tables with realistic mock data, allowing you to test your application immediately.
Seamless Integration: Once the schema changes are applied, the Builder can automatically generate the corresponding Models, Controllers, and Pages, that will appear in the corresponding hierarchies instantly.

This evolution turns database design from a manual chore into a high-speed conversation, allowing you to iterate on your data structure as fast as you can think.

Diagnostics

The original roadmap included a "Toolbox", a collection of wizards for complex configuration tasks. In the era of the Digital Workforce, we realized that static wizards are obsolete.

Now, if you need a specific feature (like "Add an Approve button") you simply ask the Builder. The Builder generates a precise Cheat Sheet of human-friendly and machine instructions and offers to "Apply All" automatically. The Builder is the ultimate Toolbox.

This shift allowed us to focus on a deeper need: Transparency.

The "Glass Factory" Philosophy A common complaint about high-productivity platforms is the "Black Box" problem since you don't know what the engine is doing under the hood. In Release 8.9.46.0, we are turning the lights on.

We are introducing Diagnostics, accessible via the Pulse icon in the bottom-left corner of the App Studio (available in both App and API modes).

The Heartbeat: Diagnostics provides a real-time, reverse-chronological log of the last 100 execution events. You can see the exact SQL queries being executed against your database, the raw HTTP requests sent to external APIs, and any runtime errors that occur.
Deep Links: Every log entry is hyperlinked. If you see a SQL query triggered by a specific data view, clicking the link opens the App Explorer directly to that specific Controller and View configuration.
AI Remediation: Diagnostics is integrated with the Builder.
- SQL Analysis: Click the "Lightbulb" on a complex query, and the Builder will explain exactly how the Axiom Engine applied paging, filtering, and security rules to your declarative model.
- Error Fixing: Click the "Magic Button" on an error log. The Builder will analyze the stack trace and your metadata to propose a concrete fix.

With Diagnostics, Code On Time is no longer a black box. It is a Glass Factory, giving you total visibility into how your metadata becomes working software.

Content Hub

Originally, the Content Hub was designed to solve a simple problem: developers hate writing documentation in clunky CMS interfaces. We built a bridge allowing you to write in Google Drive or Office 365 and publish directly to your application.

In the era of the Digital Workforce, this feature has evolved into something far more critical: The Corporate Memory.

Headless CMS: Turn your existing cloud storage (Google Drive, OneDrive) or file system into a robust content repository. Write your user guides, release notes, and marketing pages in the tools you already know, and let the integrated rendering engine publish them as SEO-optimized HTML or AMP directly within your app.
The Knowledge Graph: The Content Hub doesn't just serve static pages. It dynamically merges your editorial content (Policies, Tutorials) with the application's live metadata (Schema, Controllers). This creates a "Composite Truth", a single source of knowledge that is always in sync with your software.
Operational Tuning (Soft Guardrails): This is the steering wheel for your Co-Worker. While ACLs provide hard security guardrails, the Content Hub allows you to define "Soft Guardrails" - business policies and preferences.
- Scenario: Your CEO wants to update the discount policy. They don't need to file a ticket. They simply edit the "Discount Policy" document in Google Drive.
- Result: The Content Hub detects the change and injects the new instruction into the HATEOAS hint for the relevant controller. The very next time a Co-Worker attempts to apply a discount, it reads the updated policy and acts accordingly.
Agent-Ready Output: Content published via the Hub is automatically exposed via the content-hub API endpoint as machine-readable JSON and Markdown. This gives your Digital Workforce instant access to your organization's wisdom without complex vector database training.

With Content Hub, you are not just managing a website; you are curating the brain of your Digital Workforce.

Access Control List (ACL)

While SACR provides powerful data filtering, the Access Control List (ACL) is the ultimate security framework for mission-critical applications.

The core philosophy of the ACL is "Deny-by-Default". When you enable the ACL framework, every resource in your application (pages, data controllers, and individual actions) is instantly locked. Nothing is accessible to any user (human or Agent) until you explicitly grant permission.

We are bringing ACL management out of the shadows. Previously requiring manual JSON configuration, ACL rules are now managed directly in the App Explorer under a dedicated section in the Settings hierarchy.

Granular Control: Go beyond simple roles. Define exactly which roles can Read, Create, Update, or Delete on specific controllers.
Graceful Degradation: The framework intelligently handles partial access. If a user is granted access to a Page but denied Read access to the Data, the application will not crash. Instead, it injects a WHERE 1=0 condition, rendering the UI correctly but displaying empty grids. This ensures a stable user experience without leaking data.
Dynamic UI & RLS: ACLs are not just switches; they are logic. You can bundle permissions into Groups, define Row-Level Security (RLS) expressions, and even trigger Dynamic UI Modifications (like changing view labels) based on the user's role.

For the Digital Workforce, the ACL is the foundation of trust. By operating within a "Deny-by-Default" environment, you can deploy autonomous Agents with the certainty that they can strictly access only what is explicitly authorized.

.NET Core 10 in v10 (Fall 2026)

While Version 9 focuses on the developer experience (App Studio) and the AI interface (Digital Workforce), Version 10 focuses on the raw power of the engine itself.

In Fall 2026, Code On Time will complete its migration to .NET 10, effectively replacing the underlying server-side framework.

Code On Time: Anywhere: For the first time, your applications will run natively on Linux and macOS, in addition to Windows. This unlocks the ability to deploy Headless Agent Hosts in lightweight Docker containers or Kubernetes clusters, drastically reducing cloud infrastructure costs for large Agent fleets.
The Performance Jump: .NET 10 offers massive performance gains over the legacy .NET Framework 4.8. Expect your Axiom Engine to process API requests and HATEOAS transitions significantly faster, making your Co-Workers snappier and more responsive.
Seamless Migration: The beauty of our metadata-driven architecture is portability. Your projects built in v9 (using App Studio and App Explorer) will upgrade to v10 with minimal effort. The definition of your application remains the same; we are simply upgrading the engine that runs it.
Any OS, Anywhere: Deploy your generated applications to cost-effective Linux servers (Ubuntu, Debian, Alpine) or host them on macOS infrastructure.
Cloud Freedom: Move your workloads freely between Azure, AWS, and Google Cloud without worrying about underlying OS licensing or compatibility.

Version 10 ensures that the enterprise software you build today is ready for the cloud-native infrastructure of the next decade.

Cross-Platform Development in v11 (Winter 2027)

While Version 10 unlocks cross-platform deployment for your applications (running the Axiom Engine on .NET Core), the development tools themselves have remained tied to Windows. In Winter 2027, we will break that final chain.

Version 11 marks the migration of the App Generator (codeontime.exe) itself from the legacy .NET Framework to .NET Core.

Build on Any OS: For the first time, you will be able to install Code On Time natively on macOS and Linux. Whether you prefer a MacBook Pro or an Ubuntu workstation, you can build, generate, and manage your projects without relying on Windows virtual machines or Parallels.
CI/CD Native: This migration allows the App Generator to run inside standard Linux-based CI/CD pipelines (GitHub Actions, GitLab CI). You can trigger a "Headless Generation" command in the cloud whenever you push to your repository, automating your entire build process on cost-effective Linux infrastructure.
Unified Ecosystem: With this release, the entire stack (the apps you build and the tool you build them with) will run on the modern, cross-platform .NET Core architecture.

With Version 11, the transformation is complete: Build Anywhere, Deploy Anywhere.

History

See the previous iterations of the v9 roadmap:

Roadmap 2026 - 2027

A Glimpse into the Future of the Digital Workforce Platform