ARKIAGENT · THE RUNTIME INSIDE YOUR COMPUTER

Stop asking AI questions. Start dispatching work.

ArkiAgent runs inside your isolated VM and reasons against your data under your own OpenRouter key. Give it work — a dashboard, a doc, a brief, a phone call — and it ships it against your Five Pillars ontology. Skills hot-reload, memory survives restarts, and every action is auditable through Arkivist. Your account, your model, your bill.

See a live agent

What ArkiAgent ships for you.

Most “AI assistants” return text. ArkiAgent returns artifacts — working dashboards, structured docs, executed queries, anchored briefs. The output goes where your team already works: your boards, your file store, your knowledge graph.

Underneath it sits a real toolchain: a Factory that dispatches agents to do work, a widget composer that turns questions into dashboards, a notes system that writes straight into your Nextcloud, and a Five Pillars ontology that anchors every output to a provable lineage.

Agent Factory - Dispatch agents, not prompts.

Open the Factory, describe the job, send it. An agent spins up inside your VM, runs against your MCP tool catalog, and lands the result on your board. No copy-paste, no follow-ups, no “as an AI language model”.

  1. STEP 01

    Describe the work

    Plain language. “Build me a Q3 churn dashboard.” “Draft the legal brief from these three rulings.” The Factory captures the brief, not a prompt.

  2. STEP 02

    An agent runs inside your VM

    Reads your data through MCP. Calls the tools it needs. Asks for approval when it would touch anything sensitive. Reasoning goes out under your OpenRouter key — not ours.

  3. STEP 03

    The artifact lands on your board

    A widget, a note, a file, a query result. Versioned, traceable, and connected back to the brief it came from.

The live runtime - A real agent loop — skills, memory, and self-modification.

ArkiAgent isn't a single prompt. It's a runtime with a toolset it can grow, a memory that outlives restarts, and the ability to extend itself within guardrails — hosted by Parrot, the Rust edge engine inside your VM.
  • Hot-reloading skills. Drop a skill into your Nextcloud and the agent picks it up live — no redeploy. Its capabilities are files you control, not a vendor roadmap.
  • Persistent memory. Behavior and notes survive restarts and are injected with context awareness, so the agent remembers how your team works.
  • Self-modification. Within guardrails, the agent edits its own skills and memory — improving how it works the more it works.
  • Voice control. Drive the agent by phone through the Twilio bridge, with Cartesia voice and a human-takeover operator console.

On-the-fly dashboards - Ask for a view. Get a working dashboard.

Six widget types ship today. Each one is a real, typed renderer wired into the agent — not a screenshot, not a Slack reply. Click anything to ask the agent why.
  • Ontology graph. Your Five Pillars as a live node-link diagram. Click any node to ask the agent why it exists, what it touches, and what it depends on.
  • Lineage tree. Trace any record back to source. Every transformation, ingest, and inference shows up as an edge — not a black box.
  • Neighborhood view. Pick an entity, get the graph around it. Customers, contracts, claims, evidence — see how things actually connect.
  • Path queries. Ask "how is X related to Y?" Get the shortest path through your ontology, ranked by confidence.
  • KG sources. Which authoritative sources back which claims? Filter, group, audit. The provenance is the product.
  • Web research catalog. Send the agent to the web. It comes back with a catalog of sources, ranked and citable, dropped straight onto a board.

Docs & notes

Briefs and reports drop into your Nextcloud — versioned, searchable, yours.

Tell the agent to write something — an incident postmortem, a customer brief, a procurement memo — and it writes the file straight into your Nextcloud. Not a download, not an email attachment. A real document in your file store, with version history and full-text search from the moment it lands.

Notes and briefs the agent creates are first-class citizens. They're indexed against the ontology, linked back to the brief that produced them, and stored in your Nextcloud under your LUKS-derived encryption key — Arkivist never sees them.

Five Pillars ontology - Every output traces back to your ontology.

Five Pillars is the shared schema that holds your domain together: entities, relationships, claims, evidence, decisions. The agent reasons against it. The dashboards render it. The lineage anchors to it.

What the agent sees

A typed graph of your business — not a vector blob.

Vector search guesses at similarity. The ontology knows what things are: a customer, a contract, a claim, a source. The agent navigates that structure deliberately, which is why its answers cite specific edges instead of hand-waving.

What that gets you

  • Click-to-ask: any node in any dashboard becomes a question. The agent answers with the subgraph it used.
  • Provable lineage: every claim the agent produces is backed by a path through the ontology — visible, auditable, exportable.
  • No silent drift: when your data changes, the graph changes. Dashboards rebuild against the new state instead of going quietly stale.

Connected to Arkivist

Your agent has a Mothership.

ArkiAgent doesn't run in a vacuum. Identity, skills, memory, and the decision-protocol verification layer all come from the ARKIVIST Mothership. Skills update on hot reload. Memory survives restarts. Every agent action that produces a claim gets decomposed, verified, and anchored to a public ledger — the same pipeline that powers Arkivist's verification protocol.

Your agent is yours. The Mothership is how it stays trustworthy.

See ARKIVIST.io →

Watch an agent ship work in your environment.

We'll provision a live VM with ArkiAgent running. You bring the brief; we'll show you the artifact land.

Book a Demo