> ## Documentation Index
> Fetch the complete documentation index at: https://docs.10et.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Domain Engine

> TenetEntity, TenetConnector, and the World class — domain-agnostic agent runtime

The domain engine provides the product-facing API for building agent applications. It wraps TENET's internal infrastructure (memory, training, policy, eval) into a clean interface that any app can use.

## Core Types

### TenetEntity

Generic entity that any domain maps to:

```typescript theme={null}
interface TenetEntity {
  id: string
  source: string           // which platform/connector
  sourceId: string         // platform-specific ID
  name: string
  metadata: Record<string, any>
  funnelStage: string      // from template FUNNEL.md
  temperature: 'hot' | 'warm' | 'cooling' | 'cold'
  createdAt: Date
}
```

* **Dating**: Entity = Match
* **Sales**: Entity = Lead
* **Recruiting**: Entity = Candidate

### TenetConnector

Typed interface to external platforms:

```typescript theme={null}
interface TenetConnector {
  authenticate(credentials: ConnectorCredentials): Promise<void>
  syncEntities(since?: Date): Promise<TenetEntity[]>
  syncInteractions(entityId: string): Promise<TenetInteraction[]>
  send(entityId: string, content: string): Promise<{ platformMsgId: string }>
  getProfile(entityId: string): Promise<Record<string, any>>
}
```

### TenetRewardFunction

Domain-specific reward definitions:

```typescript theme={null}
interface TenetRewardFunction {
  signals: RewardSignal[]
  calculate(context: RewardContext): number
}
```

## The World Class

The `World` (or `DomainEngine`) wraps everything:

```typescript theme={null}
import { World } from '10et'

const world = await World.create({
  template: 'saas',
  storage: cloudStorage(userId),
  connectors: [github(token), linear(token)],
})

await world.sync()                          // pull from platforms
const action = await world.suggestAction(issueId)  // memory + policy
await world.recordOutcome(actionId, 'merged')  // training signal
await world.train()                         // nightly: policy improves
```