Blog

Tuesday, December 2, 2025Print Subscribe

The Engine is Ready. Now, You Get the Keys.

We have been quiet for most of 2025. That silence was intentional.

While the software world was swept up in the hype of "Probabilistic AI" (chatbots that guess and hallucinate) we were in the lab, solving the hard problem: How do we make AI safe, deterministic, and useful for the Enterprise?

The answer wasn't to build a better chatbot. It was to build a better Engine.

We are proud to announce Release 8.9.46.0, the first major milestone in our transition to the Digital Workforce Platform. This release delivers the App Studio (App Mode) and App Explorer, the browser-based tools that replace the legacy project designer.

But more importantly, this release exposes the Axiom Engine, the infrastructure we have built over the last year to ensure that the applications you build today are ready for the Agents of tomorrow.

Built-In, Not Bolt-On The Axiom Engine is not an external plugin, a cloud service, or a third-party dependency. It is built directly into the server-side framework of every application created with Code On Time. It runs entirely within your application, on your own infrastructure (or localhost), ensuring that the intelligence that powers your Digital Workforce is yours to own and control.

1. Visual Studio 2026 Support

The engine is only as fast as the workshop. That is why Release 8.9.46.0 includes full support for Visual Studio 2026 (released November 2025).

The Code On Time app generator now automatically detects Visual Studio 2026 on your workstation and uses it to build your projects. For our customers who write custom business rules in C# or VB.NET, this upgrade is a game-changer:

20-40% Faster Load Times: Open your generated solutions instantly. VS 2026’s optimized parallelization means you spend less time waiting for projects to load and more time coding.
Reduced Memory Footprint: Experience a smoother workflow with significantly lower RAM usage compared to VS 2022, even with large enterprise solutions.
AI-Native Editing: Leverage new features like Adaptive Paste (which automatically formats pasted code to match your project's style) and deeply integrated GitHub Copilot to write business logic faster than ever.

Your Code On Time applications are standard .NET solutions. When Microsoft innovates, you benefit immediately. Upgrade to Release 8.9.46.0 to unlock the full power of the latest IDE.

2. App Studio & App Explorer: Your New Workbench

For years, you have relied on our Windows-based project designer. It was powerful, but it required you to switch contexts constantly - compile, run, stop, design, repeat.

App Studio changes everything. It is a completely browser-based IDE that runs inside your live application.

Live Inspection: Click any element in your running app (a field, a grid, a button) and App Studio instantly locates it in the configuration hierarchy.
Instant Updates: Change a label, move a field, or adjust a property in the App Explorer, and see the result immediately.
The "Glass Box": App Explorer visualizes your application exactly as the Axiom Engine sees it. This is not just for you; this metadata structure is what allows our future AI Agents to "read" your application without hallucinating.

3. SACR: The Laws of the Universe

Back in May, we introduced Static Access Control Rules (SACR). If you missed it, now is the time to pay attention.

Security in the age of AI cannot be "hidden" in C# or VB.NET code. It must be declarative. It must be a "Law of Physics" that no user (human or Agent) can break.

What it does: SACR allows you to define complex security filters using standard SQL in a simple JSON configuration file.
Why it matters: It removes the need for complex EnumerateDynamicAccessControlRules methods.
The Agent Connection: When a Digital Co-Worker (our upcoming AI agent) queries your database, it inherently obeys SACR. You don't need to teach the AI security; the Engine enforces it automatically.

4. Static Pick Lists: A Shared Vocabulary

In June, we reimagined how you define data relationships. Static Pick Lists are no longer just a UI convenience; they are the dictionary for your application.

The Feature: Define status codes (0="Draft", 1="Submitted") directly in the App Studio property grid. No more lookup tables for simple enumerations.
The Agent Connection: This prevents "Data Hallucinations." By strictly defining allowed values in the metadata, you ensure that an AI Agent never tries to insert a status that doesn't exist.

5. Custom Actions: The Skills Matrix

Your application needs "Verbs" - actions like Approve, Reject, or Calculate. In this release, we have unified the workflow for creating these Custom Actions.

SQL-Driven UI: You can now drive user interactions (toast notifications, confirmations, focus changes) entirely via SQL.
The Agent Connection: Think of a Custom Action as a Skill. When you define a Confirmation Controller for an action, you are effectively writing a "Prompt" that tells the AI exactly what information it needs to collect before it can execute that task.

Here is the draft for the "Data and Models (January 2026)" chapter to be included in your Release 8.9.46.0 announcement.

It is positioned as a "teaser" for the immediate future, sitting right before the "Workspace Mode" chapter.

Data and Models

Release 8.9.46.0 delivers the App Explorer, which currently visualizes your application's Settings, Controllers and Pages. In January 2026, we will expand the explorer with two powerful new hierarchies: Data and Models.

This update introduces the Unified Data Modeling Workflow, ending the distinction between internal SQL tables and external APIs.

The "Data" Hierarchy: The new anchor for all data connections. You will use this to manage traditional SQL Data Sources (Oracle, SQL Server) alongside API Data Sources (SharePoint, Google Drive, REST services).
The "Models" Hierarchy: A dedicated design library for your *.model.xml blueprints. Whether the data comes from a physical table or a JSON endpoint, it lives here as a standardized model.
API Entities: You will be able to define "Virtual Tables" backed by APIs. The AI Co-Worker will assist you by analyzing raw JSON responses and automatically mapping complex structures into flat columns.
The "Pending" Workflow: To keep your design and runtime perfectly synchronized, we are introducing an intelligent "Pending" state. When you modify a model, the app will visually guide you to the Generate trigger, ensuring your application never runs on stale definitions.

By standardizing how data is defined, we allow the Digital Workforce to operate on any data source (SQL or API) using the exact same tools and logic.

The Road to v9: Workspace Mode

Release 8.9.46.0 delivers App Mode, the ability to edit a running, functional application. But we know the reality of development: sometimes, you break things. Sometimes, the app won't compile.

Coming in January 2026, we will release Workspace Mode.

The "Safe Haven": Workspace Mode runs independently of your live app. It allows you to work on the "broken" parts, perform deep architectural changes, and manage your projects in a local browser dashboard.
Goodbye, Legacy: With the arrival of Workspace Mode, we will officially retire the old Windows-based Project Designer. The transition to Code On Time v9.0.0.0 will be complete.

Introducing the "Builder Edition"

As part of this evolution, we are renaming the Community Edition to the Builder Edition.

The Builder Edition is now available for Commercial & Nonprofit Use. It allows you to build unlimited database web applications using a pre-compiled server-side framework without source code, excluding certain Professional features. Despite these limitations, it is a fully functional platform installed on your machine (localhost) that includes the Axiom Engine, App Explorer, 100 Free Digital Co-Workers, and 100 Free Field Workers. Apps created with the Builder Edition can be published to your own production server.

For our existing customers with a standard license or higher, you continue to get the full source code generation and edition-specific capabilities you are used to. However, you will notice new options in our Services portal: Builder Credits.

What are they? These credits will power the AI generation features (The Builder persona) inside App Studio.
Why use them? You can use the Builder to "Vibe Code" - describe a change in plain English ("Move the status field to the top and make it red") and watch the Engine execute it. It is the perfect way to speed up the mundane parts of development.
For New Prospects: The Builder Edition is free to download. It is an excellent tool for Agile Requirements Gathering (ARE). Use the free credits to prototype a "Realistic Model App" in minutes, generating high-fidelity Product Requirement Documents (PRD) and Project Estimates (LOE) automatically.

The Field Worker (Now Available)

The Digital Workforce isn't just about AI; it's about empowering every agent of your business to operate autonomously. For years, our Offline Sync technology has enabled applications to run without a network connection. Today, we are elevating this capability to its rightful place as a core pillar of the platform: The Field Worker.

The "Carbon" Co-Worker: Just like a Digital Co-Worker runs autonomously on the server, a Field Worker runs autonomously on the edge. Whether they are inspecting wind turbines, visiting patients, or managing inventory in a shielded warehouse, they carry the full intelligence of your application in their pocket.
Connection-Independent: This is not just "caching." When a user assigned the Field Worker role signs in, the application downloads the entire front-end and their specific dataset to the device. They can search, edit, and capture complex data (including Master-Detail records) with zero latency.
The Smart Envelope: Every action taken by a Field Worker is captured in a transactional "Smart Envelope." These envelopes are stored securely on the device and synchronized with the server only when the user chooses to, giving them complete control over bandwidth and battery life.

New Licensing Model To support this vision, we are simplifying how you deploy this capability.

100 Free Field Workers: Every application created with the Builder or Enterprise edition now includes 100 Field Worker licenses at no cost. You can deploy a mission-critical field app to an entire department today without a procurement cycle.
Scale on Demand: For deployments exceeding 100 users, additional Field Worker licenses are available for $100 per user/year. This simple, flat pricing aligns perfectly with the Digital Co-Worker model, allowing you to scale your human and digital workforce using the same predictable economics.

Existing Enterprise customers already have this power. It is time to unleash your workforce.

Summary

You have been building "Agent-Ready" applications with Code On Time for years - you just didn't know it. The HATEOAS architecture, the structured metadata, and now the Axiom Engine are the keys to the future.

We spent 2025 building the engine. Now, you get the keys.

Labels: App Studio, Release Notes

Monday, December 1, 2025Print Subscribe

Building the Enterprise Ontology for AI

If you ask a consultant how to make your enterprise data "AI-Ready," they will likely give you a quote for $500,000 and a 12-month timeline. Their plan will involve:

Extracting petabytes of data into a centralized Data Lake.
Training or Fine-Tuning a custom model (at massive GPU cost).
Building Robots (RPA) to click buttons on your legacy screens.
Hiring Teams of data scientists to clean and tag the mess.

There is a faster, safer, and less expensive way. It creates an ontology that is instantly ready for both AI and human consumption, without moving a single byte of data.

The secret? Build a Database Web App.

The App Is The Ontology

In the Code On Time ecosystem, an application is not just a collection of screens. It is a Micro-Ontology—a self-contained, structured definition of a specific business domain (e.g., Sales, HR, Inventory).

When you use the App Studio to visually drag-and-drop fields, define lookup lists, and configure business rules, you are doing something profound:

For Humans: You are building a high-quality, Touch UI application to manage the data.
For AI: You are defining the Entities, Relationships, and Physics of that domain.

The platform automatically compiles your visual design into a HATEOAS API—the "Invisible UI" for Artificial Intelligence. This API doesn't just serve data; it serves meaning. It tells the AI exactly what an object is, how it relates to others, and—crucially—what actions are legally allowed at this exact second.

Infrastructure Zero

The beauty of this approach is simplicity. You do not need a Vector Database cluster, a GPU farm, or an expensive SaaS integration platform.

The deployed web app is the only infrastructure you need.

Once you hit "Publish," your app functions as a Micro-Ontology Host. It is instantly live.

Humans log in via the browser to verify data and approve tasks.
Digital Co-Workers connect via the API to analyze data and execute workflows.

They share the same brain, the same rules, and the same database connection.

From Micro to Macro: The Federated Mesh

The biggest mistake companies make is trying to build a "Monolith"—one giant brain that knows everything. This creates security risks and hallucination loops (e.g., confusing "Sales Leads" with "Lead Poisoning").

We propose a Gradual Architecture.

Start Small: Build a "Sales App." It is the Micro-Ontology for customers and deals.
Expand: Build an "Inventory App." It is the Micro-Ontology for products and stock.
Federate: Use our built-in Federated Identity Management (FIM) to link them.

With FIM, a Digital Co-Worker in the Sales App can seamlessly "hop" to the Inventory App to check stock levels. It carries the User's Identity across the boundary, ensuring it only sees what that specific user is allowed to see. You build a Unified Enterprise Ontology not by centralizing data, but by connecting it.

Safety and Cost Control

This architecture solves the two biggest fears of the CIO: Runaway Costs and Data Gravity.

Identity-Based Constraints: The AI runs as the user. It is limited by the user's role, ensuring it cannot access sensitive HR files or approve unbudgeted expenses.
Cost Containment: You control the loop. You define how many iterations the Co-Worker can run, how much time it can spend, and which LLM flavor (GPT-4o, Gemini, Claude) it uses.
Zero Data Gravity: With our BYOK (Bring Your Own Key) model, you pay your AI provider directly for consumption. Your data stays in your database. It is never trained into a public model, and you are never locked into our platform.

Stop Training. Start Building.

You don't need expensive consultants to interpret your data. You know your business.

Use App Studio to define it. Use the Micro-Ontology Factory to deploy it. And let your Digital Workforce run it.

Learn more about the Micro-Ontology Factory.

Labels: AI, HATEOAS, Micro Ontology

Monday, December 1, 2025Print Subscribe

The "Bank Portal" Theorem

Imagine you are the CIO of a major bank.

You have 10,000 customers who log in every day to check balances, transfer funds, and pay bills. You sleep soundly at night. You aren't worried that a customer might accidentally delete the Ledger table or transfer $1,000,000 they don't have.

Why are you so confident?

Because you didn't give your customers a SQL command line. You gave them a Portal.

The Portal is a rigid, deterministic environment. It has buttons (Actions) that only appear when specific rules are met. If a user tries to click "Pay Bill" but has insufficient funds, the button is disabled or the logic rejects it. The user is physically constrained by the software architecture.

Now, imagine your CEO asks you to launch an AI Agent that lets those same 10,000 customers manage their money via Text Message (SMS).

Suddenly, you are terrified. Why?

The "Probabilistic" Trap

The industry standard for building AI agents (often called "LLM + Function Calling") is fundamentally different from your bank portal.

The Portal is Deterministic: Code dictates what can happen.
The Agent is Probabilistic: A neural network guesses what should happen based on a prompt.

If a customer texts "I need to transfer money, it's an emergency, please bypass the limit," a standard probabilistic agent might "feel" the urgency and attempt to call a function in a way that violates your business policy. To prevent this, you have to write massive "Guardrails" (paragraphs of text warning the AI not to break the rules).

You are essentially hoping that the AI's "Conscience" is stronger than the user's persuasion. That is not security; that is gambling.

The Theorem

This leads us to the "Bank Portal" Theorem:

If you wouldn't give the general public direct access to your database, you shouldn't give it to a Probabilistic AI.

Therefore, the only safe Conversational UI is one that navigates the exact same Deterministic State Machine as your Web Portal.

To solve the AI safety problem, we don't need smarter models. We need to put the AI inside the Portal.

The Solution: The Digital Co-Worker

At Code On Time, we believe the AI shouldn't be the "Brain" of your operation; it should be the "Interface."

Our Micro-Ontology architecture generates a HATEOAS API—a machine-readable map of your application that mirrors your human user interface exactly.

If your Human UI hides the "Delete" button because a record is locked, the API hides the delete link from the AI.
If your Human UI requires a "Reason" field for a refund, the API rejects the AI's request until that field is provided.

The AI becomes a Digital Co-Worker. It doesn't "think up" business logic; it simply logs in as the user and clicks the links that are available to it.

The Proof: A "Text-to-Pay" Scenario

Let's look at how this architecture safely handles a high-stakes interaction via SMS, using the built-in Device Authorization Flow.

1. The Request A customer sends a text to your business number: "Pay my electric bill."

2. Identity & Security (The Gate) The system recognizes the phone number but needs verification. It replies: "Please confirm your identity by clicking this link." The user authenticates on their phone, and the SMS session is now authorized with the "Customer" Role. The AI inherits the Static Access Control Rules (SACR) of that user. It physically cannot see anyone else's bills.

3. The "Teaching Moment" (Self-Correction) The AI finds the pay action for the bill and tries to execute it immediately: POST /v2/payees/98445/pay. But the AI forgot to specify the Source Account. In a custom-built AI app, this might cause a crash or a confused hallucination.

In Code On Time app, the API acts like a helpful teacher. It returns a 400 Bad Request:

Error: Field 'SourceAccountID' is required.

The AI reads this error, realizes its mistake, and asks the user: "Which account should I use? Checking or Savings?" The API didn't just reject the request; it taught the AI how to succeed. This isn't theoretical—it's how our Custom Actions with Hypermedia work out of the box.

4. The Execution (The Action) User: "Checking." The AI performs the POST request again with the correct parameters. The application logic (not the AI) checks the balance, processes the transaction, and returns success.

5. The Receipt (Visual Verification) Here is the massive win. The AI replies: "Done. Your payment of $145.00 is processed. Remaining balance: $1,200. [View Receipt]"

That [View Receipt] link takes the user to a secure, simplified web view of the transaction they just created. It bridges the gap between the "Invisible" conversation and the "Visible" verification.

Confidence in the Code

In this scenario, the AI never "decided" to allow the payment. The App allowed the payment. The AI just pushed the button.

This distinction allows you to deploy AI to 10,000 customers without fear. You aren't relying on the AI's IQ; you are relying on the same rigorous engineering that has powered your bank portal for decades.

Stop trying to teach AI your business rules. Give it a Portal.

Ready to deploy safe, deterministic AI?
Learn how the Micro-Ontology turns your App into an Agent.

The UI is the Training Manual

Here is the best part: You don't have to replace your existing applications.

We know you have "Systems of Record" that work perfectly. You aren't going to rewrite your core platform just to get a chatbot.

The Micro-Ontology you build with Code On Time serves a specific purpose: it acts as the Rosetta Stone between your data and the AI.

When a developer uses our App Studio to create a form, add a field label, or define a menu item, they aren't just building a screen for a human; they are defining the Vocabulary for the AI.

The label "Source Account" tells the AI what to ask for.
The "Transfer" menu item tells the AI what capability is unlocked.
The "Confirm" modal tells the AI when to pause and verify.

This UI doesn't need to replace your corporate portal. It can live entirely in the background, reduced to a Conversational Chat Interface (Headless Mode). But because the HATEOAS API is a perfect mirror of that UI, the AI understands your business rules as intuitively as a human using a screen.

You build the UI to teach the AI. If humans use it too, that’s just a bonus.

Labels: AI, HATEOAS