Foundgine

Foundgine turns a .NET application's domain model into a safe, executable interface for AI agents.

It is a domain-semantic and execution layer for AI-native applications.

Foundgine is deliberately not another LLM framework, RAG framework, MCP server implementation, ORM, workflow engine, or database.

        Claude / ChatGPT / Cursor / other agents
                         │
                     MCP / API
                         │
                         ▼
                ┌─────────────────┐
                │    Foundgine    │
                │                 │
                │ Domain semantics│
                │ Resolution      │
                │ Policy          │
                │ Planning        │
                │ Execution       │
                │ Verification    │
                │ Evidence        │
                └────────┬────────┘
                         │
              ┌──────────┼──────────┐
              ▼          ▼          ▼
          Structured   Domain     External
             data      actions     systems
              │          │
              ▼          ▼
          Database   Application services

The problem

AI agents are good at reasoning about language, but an application is not language.

A real application has:

entities
identities
relationships
business operations
authorization rules
data sources
side effects
verification requirements

Today, developers commonly bridge that gap by writing a growing collection of custom tools.

Foundgine's thesis is:

The application already contains the domain knowledge. Compile and expose that knowledge as a constrained semantic execution surface instead of teaching every agent the application independently.

The core lifecycle

DOMAIN MODEL
     ↓
SEMANTIC MODEL
     ↓
AI INTENT
     ↓
RESOLUTION
     ↓
POLICY / AUTHORIZATION
     ↓
EXECUTION PLAN
     ↓
PREVIEW
     ↓
EXECUTE
     ↓
VERIFY
     ↓
EVIDENCE
     ↓
AI RESPONSE

Not every request requires every stage. Reads can be simpler; mutations should normally pass through policy, preview/approval, execution and verification.

What Foundgine owns

Foundgine owns the application-domain boundary:

semantic entity and relationship metadata
identity and entity resolution
constrained query planning
domain-action descriptors
policy-aware planning
execution plans
execution-provider contracts
verification
evidence

What Foundgine deliberately does not own

Use existing technologies for:

LLM inference
model hosting
generic agent orchestration
generic RAG
vector databases
MCP protocol implementation
authentication infrastructure
workflow engines
message brokers
ORM/database management
hosting

Foundgine integrates with those technologies rather than recreating them.

Current repository

The active solution currently contains:

src/
├── Foundgine.Abstractions/
├── Foundgine.Foundation/
├── Foundgine.Metadata/
├── Foundgine.Semantic/
├── Foundgine.Diagnostics/
├── Foundgine.Builders/
├── Foundgine.Execution.Contracts/
├── Foundgine.Planning/
└── Foundgine.Providers/

samples/
└── Foundgine.Samples.Banking/

tests/
├── Foundgine.Tests/
├── Foundgine.Foundation.Tests/
├── Foundgine.Metadata.Tests/
├── Foundgine.Semantic.Tests/
├── Foundgine.Builders.Tests/
├── Foundgine.Diagnostics.Tests/
├── Foundgine.Execution.Contracts.Tests/
├── Foundgine.Planning.Tests/
└── Foundgine.Providers.Tests/

The active tree intentionally contains no GraphQL product project. The historical GraphQL/Graphgine engine, its source generators, and the pre-Foundgine CoffeeBeanery prototypes were removed from the tree entirely (they are still recoverable from git history) rather than kept around as an archive/ folder, so the tree only contains what the current milestones actually need.

Current E2E proof

The canonical sample is:

samples/Foundgine.Samples.Banking

It currently proves:

Customer
   ↓
Account
   ↓
Transaction

through:

Domain
  ↓
Metadata
  ↓
Dynamic Planner
  ↓
QueryPlan
  ↓
ProviderPlan
  ↓
SQL
  ↓
real SQLite database
  ↓
Result

The sample uses real SQLite and does not depend on GraphQL, Hot Chocolate, or Graphgine.

Run it with:

dotnet run --project samples/Foundgine.Samples.Banking

This is the first proof, not the final product.

The next proof

The immediate goal is to extend the Banking sample upward:

"Find Ada's checking account."
        ↓
semantic resolution
        ↓
policy
        ↓
execution plan
        ↓
real database
        ↓
evidence

Then:

"Refund Ada's last transaction."
        ↓
resolve
        ↓
authorize
        ↓
preview
        ↓
approve
        ↓
execute
        ↓
verify
        ↓
evidence

See Proof Milestones.

Architecture

Foundgine separates stable domain contracts from planning and execution:

Foundgine.Abstractions
        ↓
Foundgine.Foundation
        ↓
Foundgine.Metadata
        ↓
Foundgine.Builders
        ↓
Foundgine.Planning
        ↓
Foundgine.Execution.Contracts
        ↓
Foundgine.Providers

These are architectural boundaries, not a claim that every provider capability is complete.

See:

Important status

Foundgine is an active architecture and proof-of-concept project.

The lower execution path has a real Banking E2E proof. The AI-native layers are the next development phase:

semantic domain model
resolution
actions
policy
preview/approval
verification
evidence
MCP adapter

Do not interpret the repository as a production-ready AI agent platform yet.

Why not another AI framework?

Because the goal is deliberately narrower.

AI frameworks
    own reasoning/orchestration

Databases / ORMs
    own persistence

MCP
    owns agent-tool protocol

Workflow engines
    own durable workflows

Foundgine
    owns application-domain semantics
    and safe execution

That boundary is the product.

Documentation

License

MIT