Core Concepts

Principle 1: Why "Deterministic" Matters

LLMs are unpredictable

Large Language Models (LLMs) are powerful but inherently unpredictable. Connecting them directly to production databases or legacy APIs is a significant security and reliability risk.

Daemo is inherently constrained by design. This is its biggest strength.

Standard LLMs are probabilistic—they guess the next word. Daemo forces them to be deterministic.

• "Magical" AI tries to figure out everything on the fly. It is unpredictable and dangerous.
• Daemo is Bounded. It can only do exactly what you allowed it to do via the @DaemoTool decorator (or [DaemoFunction] attribute in .NET).

Note

Example: If you didn't tag a DeleteDatabase() function, Daemo cannot physically delete the database, no matter what the user asks. It operates strictly within a "Sandbox of Permission."

Instead of guessing an answer, Daemo synthesizes verifiable execution plans.

• Full Logic: It can perform loops, math, and data transformation securely.
• Verifiable: You can audit exactly what logic the AI constructed to solve the user's problem before it runs.

Tools that write raw SQL bypass your application layer. This is risky: they might delete data, miss critical business rules, or ignore permissions.

Daemo is NL-to-Function. It calls your C# or TypeScript methods, ensuring that every action goes through your existing validation, logging, and security checks.

Does "Bounded" Mean "Dumb"?

A common fear is that by constraining the AI, you make it "dumb" or useless—like the early days of GPT refusing to answer basic questions.

In reality, Daemo makes the agent smarter because it gives it tools.

Daemo isn't just a router; it is an Intelligent Orchestrator. It doesn't just call one function and quit. It has a memory, a plan, and the ability to reason.

Chain of Thought

It can stitch multiple functions together: findUser('Bob') → getLastOrder(id) → refund(orderId)

Memory & State

It stores objects in memory. It can "remember" the result of step 1 to use in step 3.

"Stripe-like" Robustness

We treat AI actions with the same transactional reliability as a payment processor. It's not "creative" work; it's "agentifying" your structured data to be robust, repeatable, and safe.

Tip

The Magic: You get the safety of a bounded system with the power of an agent that can reason, plan, and execute complex workflows.

Principle 2: Zero-Trust Data Access

"Zero Trust" means Daemo doesn't assume anything is safe by default—every single user request must be explicitly verified. The AI earns access to data one function call at a time. ### Your Database is Air-Gapped.

Daemo sits between the AI and your backend. It acts as a compliance manager. The Large Language Model (LLM) never touches your database directly. Your database credentials and raw tables are never exposed to the LLM provider (e.g., OpenAI, Anthropic, Google).

• Daemo (NL-to-Function): The AI requests data by calling your functions (e.g., GetUser(123)). The engine runs your code, fetches only that specific record, and returns it to the AI.
• Role-Based Access Control (RBAC): Since Daemo calls your code, it inherits your existing permission logic. If a user can't access a record in your app, they can't access it through Daemo—no risk of data leakage.

Is it "NL-to-SQL"?

No. Daemo does not talk directly to your database tables. NL-to-SQL tools write raw SQL on the fly (SELECT * FROM users) and can potentially query anything, bypassing your application's business logic. Besides the security risks, NL-to-SQL often struggle with accuracy and consistency due to the complexity of data tables.

Daemo is "NL-to-Function". It executes your Application Layer code (C# Methods or TypeScript functions). This is safer because it ensures that when a user asks to "delete a user," all your business rules (e.g. sending emails, checking balances, archiving logs, etc.) actually run.

Is it "Routing"?

Yes, but "routing" is too small a word. Daemo is a sophisticated tunnel that orchestrates a 4-step process:

1. Input: Natural Language ("Fix truck #4")
2. The Router: The Engine identifies the correct tool: TruckService.ScheduleRepair.
3. The Translator: It extracts the parameters: id=4.
4. The Tunnel: It routes that command down an encrypted control plane to the specific server where that code lives.
5. The Executor: It runs the actual C# or Node.js code on your infrastructure.

Principle 3: Role-based Access Control (RBAC)

Context Injection, Auth Tokens, Built-in RBAC

Principle 4: Easy Integration

Code-First Definition

Daemo doesn't require a complex dashboard setup. You define your tools in code, right alongside your business logic.

Integrating Daemo is a developer-centric process that enhances your existing architecture.

• No Fine-Tuning: Functions are understood immediately via their typed schemas and descriptions. No lengthy model training is required.
• Drops Into Existing Architecture: Add the SDK to your current monolith or microservice.
• Git-Native: Your AI logic is just code—it can be versioned, reviewed, and deployed alongside the rest of your application.

import { DaemoTool } from '@daemo/sdk';

class RefundService {
  @DaemoTool({ description: "Refunds a transaction for a customer." })
  async refundTransaction(args: { transactionId: string }) {
    // Your existing business logic runs here
    // The AI is forced to respect your types
    await paymentProvider.refund(args.transactionId);
  }
}

Your AI logic lives in your git repo, goes through your CI/CD pipeline, and is versioned just like the rest of your software.

LLM Agnostic

Easily switch between OpenAI, Anthropic, Gemini, or other LLM providers without changing your application code. Daemo supports Bring Your Own Key (BYOK) as well.

Principle 5: Auditable, Traceable

Full Visibility, No Black Boxes.

For developers and compliance teams, "magic" is a liability. You need to know exactly why the AI did what it did.

Daemo provides Deep Observability into every interaction.

• See the Plan: View the exact "Chain of Thought" reasoning the AI used.
• See the Logic: Inspect the synthesized execution steps before and after they run.
• See the Data: Track the exact inputs (arguments) passed to your functions and the raw JSON outputs returned.

Principle 6: Legacy Enterprise Support

Suited for the .NET Enterprise Ecosystem

Daemo is purpose-built to accommodate the modernization of existing enterprise systems without requiring a complete overhaul.