Struct Agent 

pub struct Agent<S: StateStoreBackend = StateStore, D: DatabaseBackend = Database, P: ProviderBackend = Provider, T: ToolsetBackend = Toolset> { /* private fields */ }

A live handle to one durable agent and its workspace inventory.

Construct or reopen it with crate::AgentBuilder and import AgentBackend for behavior. The handle is unique and non-Clone; its workspace type preserves the same concrete storage/provider/tool types. Explicit shutdown consumes it and settles owned work. Drop alone offers no asynchronous cleanup guarantee.

Examples

This local Custom agent uses in-memory Lance and sends no network requests.

use std::{num::NonZeroUsize, time::Duration};
use agents_kit::{AgentBackend, AgentBuilder, AgentStorage, WorkspaceBackend};
use agents_kit::config::{AgentConfig, CustomAgentConfig, CustomLoopLimits, CustomToolApproval};
use agents_kit::{model::ModelSelector, tool::ToolSelection};
use providers_kit::{Provider, ProviderConfig, config::{OllamaConfig, ProviderKind, TransportConfig}};
use storage_kit::{StateStore, state::config::{LanceStateStoreConfig, StateStoreConfig}};
let store = StateStore::connect(StateStoreConfig::Lance(LanceStateStoreConfig::memory())).await?;
let custom = CustomAgentConfig::new(ModelSelector::new("exact-model")?, ToolSelection::None,
    CustomLoopLimits::new(4, 0, 1)?, CustomToolApproval::Deny)?;
let config = AgentConfig::new(custom.into(), Duration::from_secs(10), NonZeroUsize::MIN)?;
let provider = Provider::from_config(ProviderConfig::new(
    ProviderKind::Ollama(OllamaConfig::local()), TransportConfig::default()))?;
let agent = AgentBuilder::create(config, AgentStorage::new(store)).with_provider(provider).build().await?;
let identity = agent.id();
let observed = agent.info().await;
assert_eq!(observed?.id(), &identity);

Trait Implementations

impl<S, D, P, T> AgentBackend for Agent<S, D, P, T>

where S: StateStoreBackend, D: DatabaseBackend, P: ProviderBackend, T: ToolsetBackend,

type Workspace = Workspace<S, D, P, T>

Concrete workspace implementation produced by this agent.

fn id(&self) -> AgentId

Returns the durable portable agent identity.

async fn info(&self) -> Result<AgentInfo, KitError>

Loads the current descriptive agent information.

async fn new_workspace( &self, request: NewWorkspace, ) -> Result<Workspace<S, D, P, T>, KitError>

Creates and publishes a workspace from validated portable configuration.

async fn list_workspaces(&self) -> Result<Vec<WorkspaceInfo>, KitError>

Lists the agent’s durable workspaces.

async fn workspace_info( &self, id: WorkspaceId, ) -> Result<WorkspaceInfo, KitError>

Loads descriptive information for a workspace identity.

async fn get_workspace( &self, id: WorkspaceId, ) -> Result<Workspace<S, D, P, T>, KitError>

Reopens a durable workspace as a live handle.

fn check_workspace_update( &self, request: &UpdateWorkspaceRequest, ) -> impl Future<Output = Result<WorkspaceUpdateReadiness, KitError>> + Send + '_

Performs a read-only advisory preflight for a workspace replacement.

async fn update_workspace( &self, request: UpdateWorkspaceRequest, ) -> Result<WorkspaceInfo, KitError>

Atomically applies a revision-checked portable workspace replacement.

async fn delete_workspace( &self, request: DeleteWorkspaceRequest, ) -> Result<(), KitError>

Deletes a workspace after validating its expected revision.

async fn list_models(&self) -> Result<Vec<ModelInfo>, KitError>

Lists selectable models in stable canonical-selector order.

async fn ingest_knowledge( &self, request: IngestKnowledgeRequest, ) -> Result<(), KitError>

Replaces the agent-scoped managed-knowledge source set.

async fn shutdown(self) -> Result<(), KitError>

Consumes the implementation, seals new work, and settles owned cleanup.