Documentation Overview

The runtime model, control surfaces, and integration patterns in one place.

This documentation page presents the way Agentkernet is structured for enterprise onboarding: define objectives, assign models, control memory, approve tool actions, and keep execution fully traceable.

Quick Start Runtime Contracts Examples Resources

Typical onboarding sequence

Define your model roles

Specify which models should plan, execute, verify, and recover from failure so each stage of the workflow has the right behavior profile.

Model Role Map 
models:
  planner: enterprise-planner
  executor: frontier-general
  verifier: domain-checker
  fallback: safe-recovery-model

Register memory and retention policy

Tell the kernel what belongs in short-lived session state, durable memory, and evidence stores so recall stays useful and governed.

Memory Policy 
memory:
  session_store: redis
  durable_store: pgvector
  evidence_store: documents-and-logs
  retention: policy-controlled
  summarization_mode: checkpoint-based

Expose approved tools

Connect enterprise systems as typed tools so agents can fetch, write, or coordinate actions under explicit policy rules.

Tool Policy 
tools:
  allow:
    - crm.lookup_account
    - ticket.update_status
    - warehouse.query_orders
  require_approval:
    - erp.release_payment
    - identity.grant_access

Run a governed session

Launch a session with objective scope, policy envelope, allowed tools, and execution trace enabled from the first step.

Session Request 
POST /v1/sessions
{
  "objective": "Resolve delayed enterprise order issues and prepare recommended actions",
  "profile": "support-operations",
  "trace": true,
  "policy_set": "production-governed"
}
Runtime Contracts

The main interfaces enterprises usually care about.

These contracts show how teams think about sessions, memory, tools, and audits when integrating an agent kernel into a broader application stack.

Session lifecycle

Create and supervise an execution session with objective scope, environment rules, model assignments, and trace configuration.

POST /v1/sessions

Task graph inspection

Review decomposed tasks, dependencies, state transitions, and pending approvals before or during execution.

GET /v1/sessions/{id}/tasks

Memory control

Inspect memory lanes, durable recall records, retention policy application, and compaction outputs.

GET /v1/sessions/{id}/memory

Tool registration

Define enterprise tools with schemas, permissions, execution boundaries, and approval requirements.

PUT /v1/tools/{toolName}

Execution trace export

Export model calls, tool activity, retries, escalations, and outcome metadata for observability or audit systems.

GET /v1/sessions/{id}/trace

Human approval actions

Approve, reject, or annotate tasks that require operator review before execution can continue.

POST /v1/approvals/{id}
Example Pattern

Production support workflow

A support operations team can use one planner model to break a case into fact gathering, entitlement checks, order analysis, customer response drafting, and action recommendation.

  • Retrieve order history, SLA metadata, and current account state.
  • Call approved write tools only after validation or human review.
  • Persist reasoning summary and final disposition into durable memory.
Execution Sketch 
# Session goal
"Resolve an enterprise shipping exception and prepare next-step actions"

# Planned tasks
1. fetch_case_context
2. query_order_system
3. verify_contract_terms
4. draft_customer_recommendation
5. request_human_review_if_write_action_needed

# Final outputs
- structured recommendation
- traceable evidence bundle
- memory update for future recall
Reference Material

What teams usually review before adoption.

These are the implementation areas most relevant to enterprise platform, architecture, and operations teams evaluating an agent kernel.

  • Runtime control model How planning, scheduling, routing, memory, and tool execution interact inside one kernel.
    Architecture
  • Policy and approval design Recommended patterns for risk-based approvals, environment-specific controls, and trace coverage.
    Governance
  • Memory and retrieval strategy Guidance for separating session context, durable memory, and evidence retention.
    State
  • Enterprise integration planning What to expose as tools, what to wrap behind approvals, and how to phase adoption across business units.
    Integration
Need Specific Guidance

Talk through your target workflow, model stack, and control requirements.

William Smith can walk your team through how Agentkernet would be applied to your architecture, governance posture, and enterprise systems.

Request a Briefing View Architecture