Covia Agents

Agents that work. On the Grid.

Agents that remember everything, across sessions, teams, and organisational boundaries. Persistent memory, shared state, governed context. No context starvation. No hallucination. No isolation.

Start Building Agents →Read the Docs

The Problem

Your agents are failing. And you might not know why.

Your agents fail at boundaries that live below your framework. State. Context. Identity. Audit. Every framework skips them.

Context Starvation

The agent had no idea what happened yesterday.

Every session starts from scratch. No memory, no awareness of what other agents have done.

Hallucination

It made up the customer’s order history.

Without the right context, agents fabricate confidently. Downstream agents inherit the fiction as fact.

Agent Isolation

Five agents, zero shared understanding.

Each agent is a silo. They can’t share state or coordinate without fragile point-to-point integrations.

Trust Deficit

We can’t prove what the agent actually did.

No audit trail, no real access control, no way to verify what an agent accessed or changed.

The Answer

Every agent remembers. Every agent shares. Every agent knows.

The global agentic context graph: persistent memory, governed state, and live context that flows across sessions, teams, and organisational boundaries.

Persistent Memory

Every agent remembers everything.

State persists across sessions, restarts, and failures. Your agent picks up exactly where it left off, with full context from every prior interaction.

Solves:Context Starvation
Governed Context

The right context, to the right agent, at the right time.

Agents receive verified, governed context from the graph. Not scraped, not guessed. When data is real and current, agents don't need to hallucinate.

Solves:Hallucination
Shared State

One substrate. Every agent connected.

Agents read and write to the same context graph. No point-to-point integrations. No message bus spaghetti. Adding a new agent means it immediately has access to the shared understanding.

Solves:Agent Isolation
Cryptographic Governance

Every action recorded. Every permission enforced.

UCAN tokens control access at the infrastructure level. An immutable timeline records every decision. You can prove exactly what any agent did, when, and why.

Solves:Trust Deficit

Ready to give your agents persistent memory?

Request Early Access →

Agent Superpowers

What your agents gain on the Grid.

Capabilities your agents gain from the Grid. Not features you configure. Superpowers they inherit the moment they connect.

npm install @covia/sdk

Total Recall

Your agent remembers every interaction, every decision, every outcome. Across sessions, restarts, and failures.

Zero-Trust Identity

Your agent proves who it is cryptographically. Accesses only what it's been granted. Credentials never leak.

Complete Accountability

Your agent can prove exactly what it did, when, and why. Every action is recorded in an immutable timeline.

Cross-Boundary Reach

Your agent works across teams, clouds, and organisations without sharing credentials or building integrations.

Atomic Precision

Your agent's multi-step operations either fully succeed or fully roll back. No partial failures. No corrupted state.

Always On

Your agent wakes on schedules, webhooks, or upstream events. Zero idle compute. Never misses a trigger.

Agent Types

Four patterns. One framework.

Whether you need LLM reasoning, deterministic workflows, rule-based logic, or custom code, the same framework handles state, security, and coordination.

Conversational · Reasoning

LLM Agent

Tool-call loops with persistent conversation history, preserved across sessions and restarts.

Tool callsConversation historyMulti-step reasoningTask delegation

Example use case

A financial analyst agent that reads market data, cross-references portfolio positions, and synthesises daily risk reports for compliance review.

Sequential · Deterministic

Workflow Agent

State-machine agents with guaranteed step ordering. Every transition validated, logged, and auditable.

State machineStep orderingAudit trailRetry logic

Example use case

A loan origination agent that collects documents, runs credit checks, validates against policy rules, and routes applications for approval.

Conditional · Policy-Driven

Rule Engine Agent

Business rules evaluated without LLM inference. Deterministic, zero hallucination risk.

Policy enforcementZero latencyNo hallucinationsBranching logic

Example use case

A fraud detection agent that evaluates incoming transactions against configurable rule sets, flagging anomalies and escalating to human reviewers.

Pluggable · Bring Your Own

Custom Agent

Your own transition function in any language, with full Grid infrastructure: state, federation, audit.

Custom logicAny languageRemote opsFederation

Example use case

A proprietary pricing agent that wraps an existing ML model, coordinating with inventory and demand-forecasting agents across the Grid.

Agent Architecture

Three layers under your agent. Every one pluggable.

The Covia agent architecture separates framework concerns from domain logic from LLM inference. Each layer is independently replaceable.

L1
agent:trigger

Agent Engine

Manages the agent record: inbox, timeline, status, and scheduling. Identical for every agent.

  • Atomic reads/writes of complete agent state
  • Append-only timeline for full audit trail
L2
llmagent:chat

Agent Transition

Pluggable domain logic. Conversation history, tool call loops, and state transitions.

  • Tool call loop until final response
  • Async invocations: fire-and-forget or await
L3
langchain:openai

LLM Call

Stateless LLM invocation. Provider-agnostic, isolated from agent state.

  • OpenAI, Anthropic, Ollama, Gemini
  • Credentials from encrypted secret store
typescript
// Create a Covia Agent in 3 lines
const agent = await covia.agent.create({
  operation: "llmagent:chat",
  state: {
    config: {
      llmOperation: "langchain:openai",
      systemPrompt: "You are a financial analyst...",
    }
  }
});

// Submit a task, agent wakes immediately
const job = await covia.agent.request({
  agentId: agent.id,
  input: { task: "Analyse Q1 revenue trends" }
});

// Poll or subscribe to the job result
const result = await waitForCompletion(job);

Agent Execution Flow

1Scheduler wakes agent
2L1 reads inbox + tasks
3L1 invokes L2 transition
4L2 runs tool call loop
5L2 invokes L3 LLM call
6L3 returns response
7L1 writes timeline entry
8Agent status: SLEEPING

Agent Lifecycle

Create. Deploy. Monitor. Govern.

Every agent follows the same lifecycle on the grid.

agent:create

Create

Define your agent with a config and optional initial state. The framework writes the agent record to the Grid Lattice immediately.

Technical Detail

agent:create writes: {status: 'SLEEPING', config: {operation: 'llmagent:chat'}, state: {...initialState}, inbox: [], tasks: [], timeline: []}. The agent record is content-addressed and immutable per version.
agent:request

Deploy

Submit tasks to your agent via agent:request. The scheduler wakes the agent immediately. Tasks persist in the agent record even if the agent is mid-run.

Technical Detail

agent:request creates a persistent Job in STARTED state. The Job ID is added to the agent's tasks inbox. The scheduler picks up the agent within milliseconds.
timeline + status

Monitor

Every successful run appends an entry to the agent's timeline, a complete, immutable audit trail of every action, tool call, and result.

Technical Detail

Every run appends a timeline entry: start, end, operation, state snapshot, tasks, messages, and result. The complete execution history of every agent, queryable in real time.
UCAN caps

Govern

Control exactly what each agent can do with UCAN capability delegation. Grant, restrict, and revoke permissions at any granularity.

Technical Detail

Grant capabilities at creation, narrow them per-task, revoke at any time. Runtime enforcement, not configuration-time promises. Capability-gated tools: spawn_agent, read_secret, fork_agent.

Agent States

SLEEPINGAwaiting tasks
RUNNINGExecuting transition
SUSPENDEDError, queues preserved
TERMINATEDLifecycle complete

Integrations

Covia Agents connect to everything.

Plug-and-play with your existing stack. Bring your LLM provider, your tools, your infrastructure. No lock-in.

Interface

MCP Protocol

Agents are first-class MCP servers. Any MCP-compatible client can connect.

Claude DesktopCursorCustom MCP clientsVS Code
AI Backends

LLM Providers

Swap LLM providers without touching your agent logic. Credentials live in the encrypted secret store.

OpenAIAnthropicOllamaGeminiMistral
Tool Palette

External Tools

Agents can invoke any external MCP tool alongside their default grid tools.

REST APIsDatabasesFile systemsWeb searchCustom tools
Cross-Venue

Federation

Agents can invoke operations on remote venues via federation. Delegate work across organisational boundaries.

Remote venuesPartner gridsCross-org agentsDID addressing
State & Data

Grid Storage

Persistent, versioned, content-addressed. Workspace, assets, operations, and an encrypted secret store.

WorkspaceAssetsOperationsEncrypted secrets
BYOA

Agent Frameworks

Infrastructure, not a competing framework. These run ON the Grid, gaining persistent state, context, and federation automatically.

LangChainCrewAIAutoGenHaystackSemantic Kernel

Open Source · Production Ready

Give your agents the Grid.

Deploy your first agent in minutes. Open-source, production-grade, growing community.

Request Early AccessView on GitHubRead the Docs