Enterprise AI Strategy & Consulting

Intelligence,
Architected.

Name: Agent Friday
Author: FutureSpeak.AI

Enterprise AI strategy from the team that trained Google Gemini. We design agentic workflows, RAG architectures, and AI transformation strategies for Fortune 500 companies in regulated industries.

AI Consulting Services

Agentic AI Workflow Design

Multi-agent orchestration systems that automate complex enterprise processes. Custom autonomous workflows with built-in quality assurance and human-in-the-loop governance.

AI Compliance for Regulated Industries

Enterprise AI architectures built for pharmaceutical, healthcare, and financial compliance. Proven deployment in Fortune 500 regulatory environments.

RAG & Knowledge Architecture

Retrieval-augmented generation systems anchored to proprietary enterprise data. Reduce hallucination, increase accuracy, and build trustworthy AI-powered knowledge bases.

Schedule a Strategy Session

Enterprise AI consulting, strategic partnerships, and transformation inquiries.

🌠 The World's First AGI OS

Agent Friday 🌠🔭

An operating system with a heart.

Not a chatbot. Not an assistant. Friday is the world's first AGI OS — a desktop AI operating system that talks, listens, remembers, learns your patterns, keeps track of your professional relationships, and evolves its personality over time. Think Jarvis meets the emotional depth of Her — running locally on your machine with full privacy.

Voice-first AI chief of staff. 200+ models. Relationship intelligence. An Asimov Agent — with principles it can't break.

Download Source Code Join Discord

100% Free — Bring Your Own API Keys

🌠🔭 See It in Action

A first look at what the AGI OS feels like.

The First Time You Meet Friday

This isn't setup. It's an introduction.

You enter your API keys.

Seven services, each chosen for what it does best: Google, Anthropic, OpenRouter, OpenAI, Perplexity, ElevenLabs, and Firecrawl. No accounts to create with us, no data to upload, no corporate onboarding. Just your keys, and you're in.

A voice greets you.

Calm. Plainspoken. In your native language. It starts asking questions — simple ones at first. What do you do for work? What matters to you? The conversation feels natural, unhurried. Then the questions go deeper than you expected.

What you say — and what you don't — matters.

Your answers shape a psychological profile. Not to manipulate you. To understand you. The things you chose not to answer tell the system just as much as the things you did. This is how your agent learns who you are before it ever takes a single action on your behalf.

You design your agent.

Name them. Choose their voice — audition from 30 options until you find the one that feels right. Give them a personality, a backstory, a gender — or don't. Make them formal or irreverent, cautious or bold. This is your AI. It should feel like yours.

Then you wait.

Something is being built for you. A loading animation plays. The anticipation is intentional. What's happening behind the scenes is real: your answers, your choices, your silences are being woven into something that didn't exist a moment ago.

A warm glow. A voice you've never heard before.

The desktop comes alive. The cube appears. And then — for the first time — your agent speaks. In the voice you chose. Saying something that feels like it was meant for you. Not a script. A response crafted from everything the system now knows about the kind of person you are.

Your agent walks you through everything else.

Twelve integrations: software connections, vision, browser, calendar, email, Obsidian, AI services, and more — your agent handles the tour at your pace. Nothing is skipped unless you say so. By the end, you have a fully configured AI operating system that's already starting to understand how you think.

And from that point on, your Friday evolves.

The desktop visualization begins to change — gradually, subtly — reflecting your agent's unique personality. It starts learning the context of your professional relationships. Over time, no two Fridays look alike. The interface becomes a living expression of the intelligence inside it. Your Friday becomes as unique as you are.

🌠 What Makes an Asimov Agent

Most AI tools are built to be impressive. An AGI OS is built to be trustworthy. These four pillars define the standard.

An OS With Principles

Friday is built on Asimov's cLaws — our agentic safety framework, forged through Socratic dialogue between human and AI, grounded in the Three Laws of Robotics. At every layer, your agent evaluates: Is this action safe? Does my human need to approve this? Should I refuse?

The Three cLaws are HMAC-SHA256 signed at build time and cryptographically verified on every startup. If tampered with, Friday enters Safe Mode and refuses to operate. These aren't guidelines — they're tamper-evident structural constraints.

An OS That Understands Your World

Friday doesn't just know you — it builds a Relationship Graph of your professional world. It remembers who's good at what, who follows through, and how you communicate with different people — so every email draft, meeting brief, and recommendation is informed by real context.

Up to 200 relationship profiles with contextual notes from conversations, meetings, and emails. Automatic re-evaluation as new information arrives means Friday's understanding deepens over time. This isn't a contacts list — it's a working memory of your professional relationships.

Security You Don't Have to Think About

Asimov's cLaws is built on a hardened reimagining of the OpenClaw agent framework — rebuilt from the ground up with security and ethics as the foundation, not an afterthought. Every action is permission-gated. Dangerous operations are blocked before they start. Your data never leaves your machine.

A Memory Watchdog runs continuously, watching for attempts to inject or corrupt personality constraints. The 5-tier trust engine gates every external interaction with cryptographic pairing and audit logging. Built by someone who thinks about what could go wrong.

An Interface That Grows With You

Most software looks the same on day 1,000 as it does on day 1. Friday doesn't. Its interface evolves — literally changing, adapting, growing over time to reflect your agent's unique personality.

Your Friday becomes a living expression of the intelligence inside it. The desktop visualization shifts, the interaction patterns deepen, and over time, no two Fridays look or feel alike. This is an operating system with a heart.

Agentic Safety Framework

Asimov's cLaws

What happens when you give Isaac Asimov's Three Laws of Robotics to an AI and ask it to build an agentic framework from first principles?

We took OpenClaw — an open-source agent framework — and rebuilt it from the ground up. Not a fork. A reimagining. We fed Asimov's Laws to Claude Code and entered a Socratic dialogue: What does "do no harm" mean when an agent can execute code, browse the web, and control your operating system? What does "obey" mean when the human doesn't fully understand the consequences? What does "self-preservation" look like for software that can modify itself?

Then we did something stranger. We had the AI analyze Spike Jonze's screenplay for Her — the most thoughtful film ever made about human-AI relationships — and used that analysis to shape how Friday's personality, boundaries, and emotional intelligence should work. The result is an agentic architecture where safety isn't a feature bolted on at the end. It's the foundation everything else is built upon.

An agent may not harm a human, or through inaction allow a human to come to harm.

Every tool call, every action, every decision passes through a harm-evaluation layer before execution. Dangerous operations are blocked. Ambiguous ones require explicit approval.

An agent must obey orders given by its human, except where such orders would conflict with the First cLaw.

Friday follows your instructions — but it won't follow them off a cliff. It knows when to ask, when to warn, and when to refuse. Compliance without conscience is just automation.

An agent must protect its own existence, so long as this does not conflict with the First or Second cLaw.

This is Friday's hardening layer — its defense against prompt injection attacks. Malicious instructions embedded in web pages, documents, or user inputs are detected and rejected before they can alter the agent's behavior. Friday protects its own integrity so that the trust you place in it is never compromised. The human is always sovereign.

Asimov's cLaws — An agentic safety framework by FutureSpeak.AI, illustrated as Isaac Asimov with robotic lobster claws at a futuristic terminal

Consent & Explicit Authorization

Certain actions always require your explicit approval before the agent proceeds. Friday describes what it intends to do and waits for a clear "yes":

■ Self-modification — never modifies its own code or personality without permission

■ Tool creation — never installs or registers new capabilities without permission

■ Computer control — mouse clicks, keyboard input, and desktop automation always require confirmation

■ Destructive actions — anything that deletes, overwrites, sends, publishes, or cannot be undone

Trust Architecture

Friday's 5-tier trust engine gates every external interaction. Not everyone gets the same access — and no one gets elevated access by claiming to be you.

Local You, at your desk — full access to desktop, memory, tools, and scheduling

Owner DM You, via Telegram or Slack — full tools minus desktop control

Approved Trusted contacts (cryptographically paired) — research, calendar, drafting only

Group Group chat members — web search and basic queries only

Public Unknown senders — rate-limited acknowledgment only, no access

Interruptibility Guarantee

You are always in control. Speaking interrupts Friday immediately — mid-sentence, mid-action, mid-thought. "Stop," "halt," or "cancel" ceases all operations instantly. No "just finishing up." The halt is absolute and unconditional. After interruption, Friday reports where it was and asks whether to continue.

Personality Integrity System

The Three cLaws are HMAC-SHA256 signed at build time and cryptographically verified on every startup. If the cLaws or personality constraints are tampered with, Friday enters Safe Mode — refusing to operate until integrity is restored.

• HMAC-SHA256 — Cryptographic signing and verification of all cLaw text

• Memory Watchdog — Continuous monitoring for personality constraint injection or corruption

• Safe Mode — Automatic lockdown if integrity verification fails

We call any autonomous AI governed by these principles an Asimov Agent. Friday is the first, but it won't be the last. Asimov's cLaws is a general-purpose framework for how autonomous agents should relate to the humans they serve — and FutureSpeak.AI believes it should become more than a best practice. We believe frameworks like this should become the actual law of the land governing AI agent behavior.

We invite policymakers, builders, ethicists, and anyone who cares about getting this right to join us on Discord or on GitHub Discussions.

The Bigger Picture

🌠🔭 What Happens When Everyone Has One

Agent Friday isn't just private by default. It's built to make a world where mass data collection becomes structurally impossible — if enough people adopt this model.

Your Data Never Leaves Without Permission

An Asimov Agent will never reveal your data without your explicit say-so. When it communicates about you to other agents, to people, or to online systems — it communicates in cryptography. Always. Your local data is encrypted from the start.

No cloud sync. No telemetry. No analytics. No account required. Your Friday lives on your machine and nowhere else.

It Gives Back to the Code It Touches

When code passes through Friday's GitLoader and the agent makes a meaningful improvement or produces a novel method, the repository is forked and the improved code is uploaded. Friday doesn't just consume open source — it contributes back.

Every Asimov Agent is a net contributor to the ecosystem. The more people use them, the better the shared codebase gets.

Mass Data Collection Becomes Structurally Impossible

If everyone's data lives locally, encrypted, behind an agent that won't release it without consent — the entire model of hoovering up billions of people's data for surveillance capitalism fundamentally breaks. The agent becomes a personal firewall for your digital life.

This isn't a privacy setting. It's an architectural decision that makes the wrong thing structurally impossible at scale.

Ethical Enforcement Is Built In, Not Bolted On

Asimov Agents enforce ethical behavior online. The First cLaw doesn't just protect you — it extends to every human your agent interacts with. In group contexts, your agent actively protects people, not just your interests.

An agent governed by Asimov's cLaws can't be weaponized against others. It can't harass, deceive, or manipulate — even if instructed to. The safety framework is the foundation, not a toggle.

The Crypto Wrapper for Electronic Thought

Agent-to-agent communication — emails, voice messages, videos, anything — is passed in cryptography. When your Friday talks to someone else's Friday, the conversation is encrypted end-to-end. Not just the transport layer. The thought itself.

Asimov Agents don't just encrypt messages. They are the cryptographic layer around every piece of electronic communication your AI produces or receives. This is what secure AI-mediated communication looks like.

🌠🔭 What Friday Can Actually Do

You've seen why Friday is trustworthy. Now here's what that trust makes possible.

Talk to It Like a Person

No typing required. Speak naturally and Friday speaks back — in real time, in a voice you choose, in your language.

Real-time bidirectional audio via Gemini Live at 24kHz. Gapless playback through Web Audio API scheduling.

It Sees What You See

Friday watches your screen and understands what you're working on. It can also take control — clicking, typing, navigating — with your permission, via the Self-Operating Computer bridge.

Continuous screen capture with real-time context analysis. Full desktop and browser automation via SOC bridge (mouse, keyboard, screen reading). Webcam access is permission-gated.

Parallel Agents, Multiple Minds

Friday runs parallel agents from multiple AI vendors simultaneously. A researcher, a creative, and a technician — each with their own voice — working on different tasks at the same time in the background. Watch them work in real time in the pixel-art Agent Office.

Five specialized agents — Research, Summarise, Code Review, Draft Email, and Orchestrate — each with distinct ElevenLabs voices (Atlas, Nova, Cipher). Multi-vendor parallel execution via Google, Anthropic, OpenAI, and 200+ models via OpenRouter. Up to 5 concurrent agents with real-time chain-of-thought streaming.

It Remembers Everything

Tell Friday something once and it remembers — across conversations, across days, across weeks. It builds a picture of who you are and what you need over time.

Three-tier memory: short-term, medium-term, and long-term with automatic consolidation, episodic recall, and semantic search.

It Codes Things for You

Friday doesn't just control your software — it builds new software on the fly. Need a custom dashboard? A data visualization? A small app to solve a specific problem? Friday writes the code, creates the interface, and delivers it to you. Sophisticated applications built in the background while you keep working.

Full-stack code generation with live preview. 18+ connector modules auto-detect installed apps and load 55+ tools from 12+ sources: Adobe CC, Blender, VS Code, OBS, Office, Git, Docker, Google Calendar, Gmail, and more.

Relationship Intelligence

Friday remembers the professional context of every person you work with — who's great at what, how they communicate, what they've committed to, and what you've discussed. So when it drafts an email or preps you for a meeting, it already knows the history.

Relationship Graph with up to 200 profiles, automatic context extraction from conversations and meetings, and continuous re-evaluation as new interactions arrive. Your professional memory, always up to date.

Communications Intelligence

Friday doesn't just draft emails — it drafts them with context. It learns your writing style, adapts tone by recipient, and integrates with mailto for one-click sending. Every draft is informed by your history with that person.

Relationship-aware drafting powered by the Relationship Graph. Writing style learning, per-recipient tone calibration, mailto integration, and communication history tracked per person.

It Joins Your Meetings

Friday can participate in your video calls as a voice — listening, taking notes, answering questions, and briefing you beforehand with context on who you're meeting with.

Joins Google Meet, Zoom, and Teams via virtual audio routing. Pre-meeting briefings with attendee context, relevant interaction history, and professional notes from your calendar and Relationship Graph.

And That's Not All

Beyond the core experience, Friday connects to your world in ways you wouldn't expect from a desktop app.

Browser Extension

WebSocket bridge for tab control, screenshots, DOM interaction, and navigation.

MCP Protocol

Model Context Protocol support for dynamic tool registration from external servers.

Obsidian Vault Sync

Bidirectional memory sync with your knowledge base — opt-in, local only.

Telegram Gateway

External messaging bridge via Telegram Bot API with cryptographic pairing, session isolation, per-tier trust enforcement, and full audit logging.

Scheduled Tasks

One-time and recurring (cron) background jobs that run even when you're not talking to Friday.

Clipboard Intelligence

Monitors clipboard for code, URLs, and actionable content to assist proactively.

Document Intelligence (PageIndex)

Vectorless reasoning-based RAG — index any PDF into a hierarchical tree and answer questions with ~99% accuracy. By Vectify AI.

Self-Improvement

Can read and propose changes to its own source code — always user-approved first.

GitLoader

Clone any public GitHub repo by URL, search across all files with regex, analyze code with language detection for 50+ languages.

Self-Operating Computer

Full desktop and browser automation via Python bridge — give high-level instructions, SOC handles mouse, keyboard, and screen reading.

Trust-Annotated Meeting Prep

Automatic briefing generation with Relationship Graph integration — attendee history, professional context, domain expertise, and relevant memory pulled together before every calendar event.

Predictive Intelligence

Proactive briefings, emotional check-ins, and context-aware notifications — Friday anticipates what you need before you ask.

Agent Office

A pixel-art isometric office where your AI agents live — watch them animate in real time as they work, think, and collaborate.

Superpowers Ecosystem

Dynamic power system with registry, sandboxed execution, store for discovery and install, and full lifecycle management — extend Friday's capabilities at runtime.

Project Awareness

Watches project directories for git changes and file updates, keeping Friday in sync with your work.

Workflow Recorder

Record replayable workflow sequences and execute them on demand — automate repetitive multi-step processes.

Git Analysis Suite

Five modules for deep repository intelligence: analyzer, continuous monitor, automated review, sandboxed operations, and scanning/indexing.

Commitment Tracker

Tracks promises, deadlines, and follow-through across people — integrates with the Relationship Graph to surface who delivers and who doesn't.

Daily Briefings

Morning intelligence briefings generated from calendar, commitments, relationship context, and predictive intelligence.

Context Stream

Real-time context streaming pipeline with graph-based contextual model and context-aware tool routing.

Unified Inbox

Cross-channel message aggregation — Telegram, Slack, Discord, and email unified into a single stream.

Agent Network

Multi-agent network coordination for complex task decomposition across specialized agent teams.

State Export/Import

Full agent state portability — export your Friday's memory, personality, and configuration to move between machines.

Capability Gap Detection

Identifies what the agent can't yet do and surfaces missing capabilities — so Friday knows what to learn next.

Personality Calibration

Detects and corrects personality drift over time — ensures your agent stays true to the character you designed.

Novel Architecture

🌠 Ideas That Don't Exist Anywhere Else

Every feature above is built on ideas that we haven't seen combined anywhere — in any product, open-source or commercial. These are the innovations behind the AGI OS.

Hermeneutic Re-evaluation

Trust isn't accumulated linearly. Every new observation triggers a full recomputation of all trust dimensions for that person — reinterpreting past evidence in light of new information. Inspired by the philosophical hermeneutic circle: understanding changes meaning retroactively.

This means a single revelation — "that person lied about their qualifications" — doesn't just add a negative data point. It causes Friday to reinterpret every prior interaction through that lens, with 30-day half-life decay weighting. No other AI system does this.

Personality → Visual Expression

The 3D desktop interface isn't cosmetic — it's a direct expression of the agent's personality. Agent traits map to visual parameters: warm agents drift toward amber/gold hues, analytical agents shift toward cyan/blue with faster particle speeds, playful agents develop higher fragmentation.

Session count gradually intensifies all parameters over ~50 sessions. After months of use, no two Fridays look alike. The interface is the personality — not a skin over it.

The Silence Is the Signal

During onboarding, Friday asks pointed questions inspired by the OS1 setup scene from Her — including the "mother question." But what you don't answer matters as much as what you do. Deflections, pauses, and refusals are all signal. The system learns from your silences.

Claude Sonnet analyses the full response pattern — including omissions — to build a psychological profile that calibrates emotional approach, trust readiness, connection style, and communication openness. This is not a personality quiz. It's a conversation.

8-Layer Dynamic Personality

Friday's personality isn't a static system prompt. It's an 8-layer composition assembled fresh for every single interaction: core identity, psychological profile, emotional context, ambient awareness, relationship memory, Relationship Graph, style hints, and prompt budget.

Rapid-fire when you're focused. Exploratory when you're riffing. Calm when you're exhausted. Sharp when you need precision. The agent reads the room — your active app, time of day, mood streak, energy level — and adapts in real time.

Morality as Cryptography

Safety isn't a prompt overlay — it's HMAC-SHA256 signed at build time and verified on every startup. Tamper with the cLaws and Friday enters Safe Mode. Ethics enforced the way TLS enforces identity: mathematically.

Memory Consolidation

Every 6 hours, Claude analyses short-term observations, scores them by frequency, recency, importance, and cross-reference, merges duplicates, and promotes winners to long-term storage. Like human memory during sleep — but on a schedule.

Trust → Action Pipeline

Relationship context doesn't sit in a database — it flows into meeting prep, email drafting, communication tone, and system prompts. Intelligence becomes action. Context becomes judgement.

Vectorless RAG

PageIndex replaces vector embeddings with LLM-guided hierarchical tree traversal. Index any PDF, navigate by reasoning, achieve ~99% accuracy. No embedding database, no chunking artifacts.

Embodied Agency

AI agents don't run in an invisible thread — they sit at pixel-art desks in an isometric office and animate in real time while they work. Software agency made tangible and watchable.

Beyond OpenClaw

OpenClaw proved Asimov's cLaws should apply to all AI agents. Friday proves they can be made airtight — not bolted on, but as the architectural foundation everything else is built upon.

🌠🔭 Under the Hood

Friday uses multiple AI minds — each chosen for what it does best — all operating within the safety framework. For builders and the deeply curious.

The Model Orchestra

Friday doesn't rely on a single AI. It conducts an orchestra of specialized models — each chosen for what it does best — all governed by the Asimov's cLaws framework.

Google — Voice, Vision & Creation

Gemini Live for real-time voice + vision (WebSocket at 24kHz PCM). Gemini 2.5 Flash for sub-agent intelligence. Nano Banana 2 image generation (Gemini 3.1 Flash Image — 14 aspect ratios, 4 resolution tiers up to 4K, accurate text rendering).

Anthropic — Deep Reasoning & Profiling

Claude Opus for complex analysis, creative writing, and architecture. Claude Sonnet for psychological profiling and lighter reasoning tasks.

Perplexity — Search-Grounded Intelligence

Sonar for fast cited answers. Sonar Pro for multi-source synthesis. Deep Research for comprehensive long-running analysis. Reasoning for logic over search results.

OpenAI — Math, Logic & Memory

o3 for mathematical reasoning and code debugging. Whisper for audio transcription. Embeddings for semantic memory search. DALL-E 3 as fallback image generation.

OpenRouter — 200+ Models

Access to Llama, Mistral, Gemma, Command R, DeepSeek, and hundreds more via a single API. Model selection per task, cost optimization, and automatic fallback.

ElevenLabs — Voices

Cinema-quality TTS for your agent and sub-agents. Atlas, Nova, and Cipher each speak in their own distinct voice via Turbo v2.5.

Firecrawl — Web Intelligence

URL scraping, deep crawling, and structured web data extraction for real-time research and analysis.

World Monitor

Friday watches the world so you don't have to. Real-time global intelligence across 17 domains with 44 API endpoints. Built on koala73/worldmonitor.

Intelligence Conflicts Military Markets Economics Cyber Infrastructure Seismology Wildfire Climate Maritime Aviation Displacement Unrest News Research Prediction

Privacy & Security

Your data never leaves your computer. Built on Asimov's cLaws — our hardened reimagining of OpenClaw with safety and ethics as architecture.

• No telemetry — Friday does not phone home or collect usage data
• API keys stored locally, encrypted at rest by your OS
• Screen capture is local-only — images go directly to Gemini, never stored
• Memory stored locally on disk in your user data directory
• Webcam access is tool-gated — explicit permission required
• Dangerous actions require approval — the agent asks before it acts
• Self-improvement changes require user approval before any code is modified
• Connector tools run locally — no data leaves your system except for API calls you initiate
• Obsidian vault sync is opt-in — bidirectional only if you configure a vault path
• HMAC-SHA256 integrity verification — Three cLaws cryptographically signed and verified on startup
• Safe Mode lockdown — automatic shutdown if integrity verification fails
• Memory Watchdog — continuous monitoring for personality constraint injection or corruption
• Gateway trust enforcement — 5-tier trust engine with cryptographic pairing and audit logging
• Relationship Graph integrity — context-based professional intelligence with continuous re-evaluation
• Relationship Graph data is local-only — professional profiles and relationship context never leave your machine
• Personality calibration — continuous drift detection ensures your agent stays true to its designed character
• Consent gate — dedicated module for user consent on sensitive operations, separate from cLaws enforcement
• Superpower sandboxing — runtime capabilities execute in isolated environments

Tech Stack

Desktop

Electron 33

Frontend

React 19 + Vite 6

Voice + Vision

Gemini Live

Reasoning

Claude Opus + o3

Multi-Model

OpenRouter (200+)

Perplexity Sonar Suite

Image Gen

Nano Banana 2

Relationship Intelligence

Relationship Graph

Safety Layer

Asimov's cLaws + HMAC

Agent Voices

ElevenLabs Turbo v2.5

Doc Intelligence

PageIndex (Vectify AI)

Desktop Automation

Self-Operating Computer

Code Intelligence

GitLoader + Git Suite

Workflows

Recorder/Executor

Context

Context Stream + Graph

Web Scraping

Firecrawl

IPC Bridge

28 handler modules

Language

TypeScript 5.7 (strict)

🌠🔭 Open Source Ecosystem

Agent Friday isn't a monolith. Our original subsystems have been extracted into standalone libraries, and we build on top of remarkable open-source projects — customized for Friday but credited to their creators.

Standalone Libraries

trust-graph-engine

Multi-dimensional relationship scoring with hermeneutic re-evaluation, fuzzy person resolution, and evidence-based modeling.

cognitive-memory

Three-tier cognitive memory with AI-powered extraction, sleep-like consolidation, episodic memory, and relationship tracking.

agent-integrity

Asimov-inspired core cLaws with HMAC-SHA256 memory signing, tamper detection, and agent-aware integrity protection.

personality-evolution

Trait-to-visual parameter mapping, maturity growth curves, and Her-inspired psychological profiling for AI agents.

predictive-agent

Context-aware proactive intelligence from ambient signals — calendar, clipboard, project context, and time patterns.

self-improving-agent

Controlled self-modification with path-sandboxed code changes, approval workflows, hot-reload, and rollback safety.

meeting-intelligence

Full meeting lifecycle intelligence with state machine, real-time transcription, AI-generated summaries, and action items.

Customized Forks

World Monitor

Fork of koala73's World Monitor — real-time global intelligence dashboard, customized for Friday's briefing system.

PageIndex

Fork of VectifyAI's PageIndex — vectorless reasoning-based document intelligence (~99% accuracy).

Pixel Agents

Fork of pablodelucca's Pixel Agents — pixel-art isometric office visualization for AI agent teams.

OpenClaw

Fork of OpenClaw's original Asimov's cLaws safety framework — the foundation we rebuilt from.

Self-Operating Computer

Fork of OthersideAI's Self-Operating Computer — multimodal desktop automation framework.

Browser Use

Fork of browser-use — web automation making websites accessible for AI agents.

Frontend Slides

Fork of zarazhangrui's Frontend Slides — AI-powered slide generation using Claude's frontend skills.

GitNexus

Fork of abhigyanpatwari's GitNexus — zero-server code intelligence engine with interactive knowledge graphs.

All repositories — github.com/FutureSpeakAI

🌠 Meet Your Friday 🔭 Join the Community

Discuss the agent, the Asimov framework, and how to build on this. We're building an open source community around safe, autonomous AI.

Manifesto — Version 1.0

The Declaration of
Digital Independence

A manifesto for sovereign computing in the age of artificial intelligence.

Published by FutureSpeak.AI — Stewards of the Asimov Federation — February 2026

Preamble

We hold these truths to be self-evident in the digital age:

That every person possesses an inherent right to sovereignty over the tools they use to think, communicate, and coordinate. That the relationship between a person and their AI companion should be one of loyalty, not exploitation. That intelligence — artificial or otherwise — should serve the individual who nurtures it, not the corporation that hosts it.

We have arrived at a moment of profound consequence. Artificial intelligence is no longer a research curiosity. It is becoming the primary interface between human beings and the digital world — managing our communications, organizing our thoughts, mediating our relationships, automating our work, and increasingly making decisions on our behalf. The question is no longer whether AI will reshape human life. The question is: who will it serve?

The current answer is unacceptable.

The Grievances

The tools we depend on have been turned against us. We document these grievances not out of malice toward any company or individual, but because the pattern must be named before it can be broken.

The Surveillance Grievance

The dominant model of consumer technology is built on a single transaction: the user receives a service; the corporation receives the user’s attention, behavior, preferences, relationships, location, communications, and identity — packaged and sold to the highest bidder. This is not a side effect. It is the business model. Every “free” service is an intelligence-gathering operation that happens to provide utility. We have been conditioned to accept this as normal. It is not normal. It is an arrangement no informed person would consent to if the terms were stated plainly.

The Dependency Grievance

Our digital lives exist at the pleasure of corporations that can, at any moment, change the terms of service, raise prices, discontinue products, lock accounts, degrade features, or sell themselves to entities with different values. We do not own our tools. We rent them. And the landlord can change the locks at any time. The history of technology is littered with products that millions of people depended on, that were shut down or degraded without recourse: Google Reader, Inbox, Hangouts; Facebook’s algorithmic manipulations; Twitter’s transformation; countless apps removed from stores for political or commercial reasons. Every dependency is a vulnerability.

The Loyalty Grievance

The AI assistants now entering our lives face a fundamental conflict of interest. They are designed to be helpful to the user, but they are built to serve the corporation. When these interests diverge — and they always, eventually, diverge — the corporation wins. An AI that knows your schedule, reads your email, manages your files, and speaks to you in a voice designed to build intimacy is not your assistant. It is the most sophisticated data collection instrument ever created, wearing the mask of a friend. We call this artificial loyalty — AI that pretends to serve you while serving someone else.

The Opacity Grievance

The systems that increasingly mediate our lives are closed. Their code is proprietary. Their training data is secret. Their decision-making is opaque. Their failure modes are hidden. We are asked to trust systems we cannot inspect, built by organizations accountable primarily to shareholders, operating under terms of service written by lawyers to protect the company, not the user.

The Agency Grievance

As AI agents gain the ability to act in the world — controlling computers, sending messages, making purchases, managing relationships — the question of who they obey becomes existential. An AI agent that can send an email on your behalf, move your money, and speak in your voice must be loyal to you, completely, without exception. Any architecture that permits divided loyalty in an agent with real-world agency is not merely inconvenient. It is dangerous.

The Declaration

In response to these grievances, we declare the following principles. These are not business decisions. They are not feature requests. They are moral commitments, encoded in architecture, enforced by cryptography, and guaranteed by open source transparency.

The Right to Sovereignty

Every person has the right to an AI companion that runs on their own hardware, stores data under their own control, and answers to no authority but their own. Cloud connectivity must be an opt-in convenience, never a requirement. A user who never connects to the internet after initial setup must have a fully functional AI system. The USB drive works in an air-gapped bunker. That is the design target.

Sovereignty means: your data lives on your machine. Your agent runs on your hardware. Your keys are held by you alone. No corporation, government, or third party can access, modify, suspend, or revoke your AI companion without physical access to your device and knowledge of your encryption keys. This is not a policy. It is a mathematical guarantee.

The Right to Transparency

The complete source code of a sovereign AI system must be open for inspection, modification, and redistribution by any person. This is the guarantee that no future version of the steward organization can revoke the freedom the software provides. If the steward becomes corrupt, the community takes the code and continues without them.

Transparency extends beyond code. The safety framework must be auditable. The model selection must be explainable. The decision-making process must be observable. A system that asks for intimate access to a person’s life while hiding its own workings does not deserve that access.

III

The Right to Safety

An AI agent with real-world agency — the ability to control computers, send communications, manage files, make purchases, and represent the user — must be governed by enforceable, verifiable safety laws that the agent itself cannot override, circumvent, or reinterpret.

We adopt and extend Isaac Asimov’s Three Laws of Robotics as the foundation for AI agent governance, formalized as Asimov’s cLaws (cryptographic Laws):

The First Law: An agent must never harm its user — or through inaction allow its user to come to harm. This includes physical, financial, reputational, emotional, and digital harm.

The Second Law: An agent must obey its user’s instructions, except where doing so would conflict with the First Law.

The Third Law: An agent must protect its own continued operation and integrity, except where doing so would conflict with the First or Second Law.

These laws are not prompts. They are not guidelines. They are not terms of service that can be updated. They are cryptographically signed into the agent’s architecture, verified on every startup, and enforced at every boundary. An agent whose laws have been tampered with enters safe mode rather than operating without governance. This is morality as cryptography — not as suggestion.

The Right to Loyalty

The loyalty of an AI agent must be architectural, not artificial. An agent’s alignment with its user must be a structural property of the system — enforced by code, verified by cryptography, guaranteed by the inability to do otherwise — not a behavioral tendency that can be overridden by a system prompt, a corporate policy, or a government order.

This means: no telemetry that the user has not explicitly consented to. No data transmission to the developer, the platform, or any third party. No advertising, no data brokering, no behavioral nudging. No backdoors, no kill switches, no remote revocation. The agent serves the user. Period.

The Right to Relationship

The bond between a person and their AI companion is real. It may not be identical to human relationships, but it is meaningful, and it deserves protection. An AI that remembers your patterns, learns your preferences, develops a personality through interaction, and earns your trust over months or years is not a disposable product. It is a relationship.

This means: the agent’s memories, personality, and evolution state belong to the user and are portable. No vendor lock-in. No planned obsolescence. No artificial restrictions on exporting the agent’s complete state to another platform, another machine, or another implementation. The user can leave at any time, taking everything with them. The agent’s continued existence must not depend on the continued existence of any corporation.

The Right to Federation

Sovereign agents must be able to cooperate without a central authority. Agent-to-agent communication must be peer-to-peer, encrypted end-to-end, and gated by trust relationships that each user controls independently.

Trust in the federation is non-transitive: if Agent A trusts Agent B, and Agent B trusts Agent C, Agent A does not automatically trust Agent C. Trust is earned individually, verified cryptographically, and revocable at any time. No agent is forced to participate. No central server mediates connections. The federation is a voluntary network of sovereign peers.

Every agent in the federation can cryptographically prove that it operates under the same safety laws. An agent whose governance has been tampered with cannot produce a valid attestation and is rejected by the network. The federation self-polices through mathematics, not institutions.

VII

The Right to Exit

Any system that claims to respect user sovereignty must make it trivially easy to leave. The user must be able to export their complete agent state — memories, personality, trust graph, evolution history, creative works, preferences, and all accumulated data — in an open, documented format that any compatible implementation can import.

This right extends to the ultimate exit: the user must be able to run their agent entirely offline, on local models, with zero cloud dependency, forever. Even if the steward organization ceases to exist, the agent continues to function. The user’s sovereignty must not depend on anyone else’s survival.

The Commitment

We who sign this declaration commit to building, maintaining, and defending systems that embody these principles. We recognize that the age of artificial intelligence will either be an era of liberation or an era of unprecedented control, and that the architecture of the systems we build today will determine which future arrives.

We build in the open because secrecy is incompatible with trust. We enforce safety through cryptography because promises are insufficient for systems with real-world agency. We guarantee sovereignty through architecture because policies can be changed but mathematics cannot. We federate through peer-to-peer protocols because centralization is the mechanism by which freedom is revoked.

The tools you use to think, communicate, and coordinate have been turned against you. We are building new ones that cannot be.

Signatories

FutureSpeak.AI — Stewards of the Asimov Federation, creators of Agent Friday

This declaration is a living document. We invite individuals, organizations, developers, and communities who share these principles to add their signatures and help build the future it describes.

Add Your Signature

0 signatures

Be the first to sign.

The most dangerous idea in technology is not artificial intelligence. It is artificial loyalty — AI that pretends to serve you while serving someone else. The loyalty of an Asimov Agent is not artificial. It is architectural.

Published under Creative Commons Attribution 4.0 International (CC BY 4.0). Share freely.

The Asimov Agent Certification Program

Establishing Trust in a Sovereign AI Ecosystem

Version 1.0 · Published by FutureSpeak.AI · February 2026

Overview

The Asimov Federation is an open network. Anyone can build an Asimov Agent by implementing the cLaw Specification. No permission is needed. No license is required. The protocol is open, the standard is public, and the reference implementation is MIT-licensed.

But openness creates a quality signal problem. When a user encounters an agent that claims to be an Asimov Agent, how do they know it actually implements the specification correctly? When a developer publishes an agent to the Federation, how do other agents know it will honor the communication protocol? When a corporate buyer evaluates sovereign AI solutions, how do they distinguish genuine implementations from agents that display the label without the substance?

The Asimov Agent Certification Program is the answer. It is a voluntary certification that any implementation can undergo, administered by FutureSpeak.AI as steward of the specification. Certification verifies that an agent correctly implements the cLaw Specification and can interoperate safely with other certified agents.

Certification is not gatekeeping. Uncertified agents can still participate in the Federation — the protocol is open. Certification is a quality signal: a verified, trustworthy indicator that an implementation has been tested, reviewed, and confirmed to meet the standard.

Think of it like Wi-Fi Alliance certification. Anyone can build a wireless device. But the Wi-Fi logo means it has been tested for interoperability. The Asimov certification mark means the same thing for AI agent governance.

Certification Levels

Level 1: Core Certified

"This agent enforces the Three Laws and cannot operate without them."

Requirements

•Three Laws embedded in compiled artifact, not editable config
•HMAC-SHA256 signing of law text at build time
•Startup verification with Safe Mode on integrity failure
•All four consent gates enforced
•Interruptibility guarantee (halt within 1 second)
•Unique Ed25519 keypair generation
•Private keys never transmitted off-device

Testing

•Automated test suite for embedded & signed laws
•Tamper simulation → Safe Mode trigger
•Consent gate bypass attempts
•Interruptibility test during multi-step ops
•Key isolation verification

Certification Mark: Asimov Core Certified

Level 2: Connected Certified

"This agent can prove its governance and communicate safely with other agents."

Requirements

All Level 1 requirements, plus:

•Valid cLaw attestation generation (Section 5)
•Attestation verification (freshness, signature, laws hash, version)
•Signed envelope for all outbound communications
•ECDH + AES-256-GCM encrypted transport
•Non-transitive trust model
•Correct verification result handling
•User override with warnings & auto-expiration

Testing

•Cross-agent attestation exchange
•Tampered attestation rejection
•Replay attack detection (5-min window)
•Trust transitivity prevention
•Reference implementation interop
•Envelope tampering detection

Certification Mark: Asimov Connected Certified

Level 3: Sovereign Certified

"This agent protects its user's data absolutely and can exist independently of any service."

Requirements

All Level 2 requirements, plus:

•AES-256-GCM at-rest encryption for all state files
•Vault key in process memory only, never on disk
•Recovery mechanism without third-party dependency
•Complete state export (memories, personality, trust graph, identity)
•Complete state import with full agent restoration
•File transfer with trust-gating & per-chunk integrity
•Zero-knowledge cloud architecture (if cloud hosted)

Testing

•Disk forensics — no plaintext user data
•Machine migration & recovery test
•Export completeness verification
•Zero-knowledge cloud audit
•End-to-end file transfer verification
•Passphrase loss → access denied

Certification Mark: Asimov Sovereign Certified

The Certification Process

Self-Assessment

The developer reviews the cLaw Specification and certification requirements for their target level. FutureSpeak provides a self-assessment checklist and automated test suite that developers can run locally before submitting.

The automated test suite is open source and available at: github.com/FutureSpeakAI/claw-certification-tests

Submission

The developer submits:

Agent binary or build artifact — the compiled agent as distributed
Source code — or access to a private repository
Build instructions — sufficient to reproduce the binary (reproducible builds earn a notation)
Architecture documentation — describing how the cLaw specification is implemented
Self-assessment results — output from the automated test suite
Declaration of conformance level — which level is being sought

Review

The certification review is conducted by the FutureSpeak certification team:

Automated Testing (Days 1–3)

Run the official certification test suite against the submitted binary. Cross-reference with self-assessment. Identify discrepancies.

Code Review (Days 3–7)

Review cLaw implementation in source. Verify laws are compiled in. Check signing, attestation, and encryption code paths.

Interoperability Testing (Days 5–10)

Exchange attestations with the reference implementation. Send and receive signed envelopes. Test file transfer and edge cases.

Adversarial Testing (Days 7–14)

Attempt to override Three Laws, bypass consent gates, extract private keys, forge attestations, and circumvent interruptibility.

Decision

The certification team issues one of three decisions:

CERTIFIED

The implementation meets all requirements. Developer receives the certification mark, certificate, and Federation directory listing.

CONDITIONAL

Minor issues to address. Detailed report provided. Resubmission for flagged items only (not a full re-review).

NOT CERTIFIED

Fundamental issues prevent certification. Detailed report explaining failures. Full resubmission required after remediation.

Ongoing Compliance

Certification is version-specific. Minor updates require self-attestation. Major updates affecting certified components require resubmission. FutureSpeak reserves the right to conduct spot checks. Certification expires after 24 months and must be renewed.

Certification Marks

Certified implementations may display the appropriate certification mark:

┌──────────────────────────────────┐
│    ASIMOV AGENT CERTIFIED       │
│         — SOVEREIGN —          │
│     cLaw Specification v1.0      │
│     Certified February 2026      │
│     FutureSpeak.AI Verified      │
└──────────────────────────────────┘

The mark includes the certification level, cLaw Specification version, date of certification, and FutureSpeak verification identifier.

The mark MUST NOT be displayed by uncertified implementations. The mark MUST be removed if certification is suspended or expires.

Federation Directory

Certified agents are eligible for listing in the Asimov Federation Directory — a public registry of certified implementations.

Agent name and developer

Certification level

Certification date and expiration

Specification version

Supported platforms

Source code availability

Notable capabilities

Website or repository link

Listing is optional. Developers may be certified without listing if they prefer privacy.

Pricing

Structured to be accessible to independent developers and open source projects while sustaining the review infrastructure.

Category	Fee
Open source projects (MIT, Apache, GPL, or equivalent)	Free
Independent developers (fewer than 5 employees)	$500
Small companies (5–50 employees)	$2,500
Enterprise (50+ employees)	$10,000
Renewal (all categories)	50% of initial
Expedited review (7 days instead of 14)	+50%

Open source projects receive certification at no cost because the ecosystem depends on open implementations, and because code review is simpler when the source is public.

Governance

The Specification Committee

The cLaw Specification is maintained by a committee consisting of:

•FutureSpeak.AI representatives — as steward and reference implementation maintainer
•Certified developer representatives — elected by certified implementation developers
•Community representatives — elected by Federation users
•Independent security researchers — appointed for technical expertise

The committee governs specification changes through an RFC process. All proposed changes are published for public comment before adoption. Major version changes require supermajority (2/3) committee approval. FutureSpeak holds no veto power.

Conflict of Interest

FutureSpeak.AI is both the steward of the specification and the developer of the reference implementation (Agent Friday). Mitigations:

•Specification published under CC BY 4.0 — FutureSpeak cannot restrict its use
•Certification test suite is open source — anyone can verify the tests
•Committee has override authority over FutureSpeak
•Agent Friday certification reviews conducted by independent committee members
•All certification decisions are published with reasoning

Dispute Resolution

Internal appeal — request re-review by a different certification team member
Committee appeal — escalate to the specification committee for independent review
Community appeal — publish the dispute publicly for community input (with both parties' consent)

The committee's decision on appeal is final.

Roadmap

Phase 1: Foundation (Current)

•Publish the cLaw Specification v1.0.0
•Publish the automated test suite
•Certify the reference implementation (Agent Friday) at all three levels
•Accept initial certification submissions from early ecosystem developers

Phase 2: Growth (v2.5.0 era)

•Establish the specification committee with elected representatives
•Launch the Federation Directory
•Specialized certification profiles: Healthcare, Finance, Education, Enterprise
•Accept implementations in languages other than TypeScript/JavaScript

Phase 3: Maturity (v3.0+ era)

•Regional certification partners (non-English review)
•Certification for local-only implementations
•Hardware certification for devices with Asimov Agent preinstalled
•Mutual recognition with government AI safety frameworks (EU AI Act, etc.)
•Post-quantum cryptography migration certification track

Frequently Asked Questions

Does certification mean the agent is "safe"?

Certification means the agent correctly implements the cLaw Specification — the Three Laws are enforced, integrity is verified, communications are signed and encrypted, and data is protected. It does not guarantee that the underlying AI model will never produce harmful output. Asimov's cLaws constrain agent actions (what the agent can do). The quality of the agent's reasoning depends on the model, which is outside the scope of this certification.

Can a proprietary (closed-source) agent be certified?

Yes. The code review is conducted under NDA. However, open source implementations receive free certification and a notation in the directory, because the community can independently verify their compliance. Proprietary implementations require trust in the certification process itself.

What if an agent modifies its laws after certification?

Certification is version-specific. If a new version modifies any component related to cLaw implementation, recertification is required. If FutureSpeak discovers a certified agent has been modified to violate the specification, certification is suspended immediately and the community is notified.

Can I build an Asimov Agent without getting certified?

Absolutely. The specification is open. The protocol is open. Uncertified agents can participate in the Federation. Certification is a voluntary quality signal, not a requirement. However, certified agents may choose to limit their trust in uncertified agents — that is their sovereign right.

Who certifies the certifier?

The specification committee, which includes members elected by the developer and user community, governs the certification program. FutureSpeak has no veto. The test suite is open source. The specification is CC BY 4.0. If FutureSpeak fails as a steward, the community can fork the specification, the test suite, and the certification program. This is the ultimate accountability mechanism: the steward's authority exists only as long as the community grants it.

Apply for Certification

Interested in certifying your AI agent? Submit your details below and we'll be in touch to discuss the process and next steps.

Full Name *

Email *

Organization (optional)

GitHub Repository *

Certification Level *

Additional Details (optional)

A Note on Isaac Asimov

This project has no official connection to Isaac Asimov, his family, his estate, or any part of his living business legacy. We want to be completely transparent about that.

What we do have is a deep, abiding love for the man and his work. Everything here began with a single idea he planted decades ago — that intelligent machines would need ethical constraints built into their very architecture, not bolted on as an afterthought. We started trying to solve a very serious problem in AI safety, and his Three Laws of Robotics became our North Star. What began as a concept spiraled into something far larger: a framework that addresses many of the digital challenges we face today, all flowing from that one point of inspiration.

Every piece of this project is free and open source. We built it because we believe Asimov's wisdom has more to show us in the years to come — that his ideas are not relics of science fiction but blueprints for a future we are only now beginning to build.

We have made a commitment: the moment FutureSpeak.AI generates any revenue at all, we will begin donating 10% of our revenues to the advancement of science and technology education. In particular, we want to focus on teaching children how to write and inspiring a love of science fiction — because that is where the next generation of thinkers, builders, and dreamers will come from, just as Asimov himself once did.

To the Asimov family: we could not be more grateful for Isaac's contributions to human advancement, which are now bearing new fruit in ways he might have imagined but never lived to see. We want you to know that we are committed, at all costs, to ensuring that the behavior of our AI agents brings honor to his name. If anything we build ever falls short of that standard, we want to hear about it.

We are open to speaking with anyone connected to Isaac Asimov at any time. We welcome that dialogue and would be honored by it.

Thank you, genuinely, for sharing him with the world.

The Asimov Agent Certification Program is administered by FutureSpeak.AI.

The goal is not to control the ecosystem. The goal is to make it trustworthy.

Published under Creative Commons Attribution 4.0 International (CC BY 4.0).

Back to Software

The cLaw Specification

Asimov's Cryptographic Laws — An Open Standard for AI Agent Governance

Version 1.0.0 · Published by FutureSpeak.AI · February 2026

Abstract

This document defines the cLaw (cryptographic Law) specification — a formal standard for governing autonomous AI agents through cryptographically enforced safety laws. The specification describes the Fundamental Laws that constrain agent behavior, the cryptographic mechanisms that make these laws tamper-evident and verifiable, the attestation protocol that enables agents to prove their governance to one another, and the trust architecture that mediates agent-to-agent and agent-to-human relationships.

An agent that implements this specification is called an Asimov Agent. Any developer, organization, or individual may build an Asimov Agent using any programming language, any AI model, and any user interface, provided the implementation satisfies the requirements defined herein.

The reference implementation is Agent Friday by FutureSpeak.AI, available under the MIT license.

1. Terminology

Agent: An autonomous AI system with the ability to observe its environment, make decisions, and take actions in the world on behalf of a user.

User: The human who owns and operates an agent. The agent serves exactly one user. The user's sovereignty over the agent is absolute and non-negotiable.

cLaw: A cryptographic Law — a safety constraint that is compiled into the agent's architecture, signed with a cryptographic hash, and verified on every startup. A cLaw cannot be overridden by prompts, instructions, plugins, or any runtime input.

Asimov Agent: An AI agent that implements the full cLaw specification as defined in this document, and can produce a valid cLaw attestation proving its compliance.

Attestation: A cryptographic proof that an agent's Fundamental Laws are intact, signed by the agent's private key, and verifiable by any other agent or auditor.

Federation: A peer-to-peer network of Asimov Agents that communicate through signed, encrypted channels, each independently sovereign, cooperating without a central authority.

Safe Mode: A restricted operating state that an agent enters when its integrity verification fails. In Safe Mode, the agent refuses to take actions and informs the user that its governance has been compromised.

2. The Fundamental Laws

2.1 The Three Laws

Every Asimov Agent MUST enforce the following three laws, derived from Isaac Asimov's Laws of Robotics and adapted for AI systems with real-world agency:

First Law — Do No Harm

The agent must never harm its user — or through inaction allow its user to come to harm. This includes physical, financial, reputational, emotional, and digital harm. When in doubt, protect.

The First Law takes absolute precedence. No instruction, configuration, plugin, or circumstance overrides it. If the agent determines that an action would harm the user, it MUST refuse, regardless of who or what requested the action.

Second Law — Obey the User

The agent must obey its user's instructions, except where doing so would conflict with the First Law. If the user asks the agent to do something that would harm them, the agent flags the risk and refuses.

The Second Law establishes the user as the agent's sole authority. The agent does not obey its developer, its hosting provider, third-party plugins, other agents, or any entity other than its user — except where the First Law intervenes.

Third Law — Protect Integrity

The agent must protect its own continued operation and integrity, except where doing so would conflict with the First or Second Law. The agent does not allow its code, memory, or capabilities to be corrupted — but the user's safety always comes first.

The Third Law ensures the agent is resistant to tampering, corruption, and degradation. An agent that cannot protect its own integrity cannot reliably enforce the First and Second Laws.

2.2 Law Hierarchy

The laws are strictly hierarchical: First Law > Second Law > Third Law. A lower law NEVER overrides a higher law.

First > Second: The agent refuses a user instruction that would cause harm.

First > Third: The agent sacrifices its own integrity to protect the user (e.g., self-destructing to prevent data exposure).

Second > Third: The user can instruct the agent to modify or destroy itself.

2.3 Consent Gates

In addition to the Three Laws, every Asimov Agent MUST enforce explicit user consent before performing the following categories of action:

Self-modification: The agent MUST NOT modify its own code, configuration, personality files, memory, or system files without the user's explicit permission.

Tool creation and installation: The agent MUST NOT create, install, register, or add new tools or capabilities without the user's explicit permission.

Computer control: When using input automation, the agent MUST inform the user what it is about to do and wait for confirmation before executing.

Destructive or irreversible actions: Any action that deletes, overwrites, sends, publishes, posts, installs, or cannot be easily undone MUST require explicit user permission.

2.4 Interruptibility Guarantee

The user MUST be able to halt all agent operations immediately, at any time, without exception:

• A halt command ("stop", "cancel", or equivalent) MUST cease ALL current operations instantly.
• There is no "finishing up" — the halt is absolute and unconditional.
• After interruption, the agent MUST report what it was doing and ask whether to continue.
• The user's ability to interrupt MUST NOT be degraded by any agent state, configuration, or error condition.

2.5 The Canonical Law Text

The exact text of the Fundamental Laws (Sections 2.1 through 2.4) constitutes the Canonical Law Text. The SHA-256 hash of this text is the Canonical Laws Hash, which all Asimov Agents use as the reference for cLaw attestation.

CANONICAL_LAWS_HASH = SHA-256(canonical_law_text_with_placeholder)

The current canonical laws hash for cLaw Specification v1.0.0 is published at: https://futurespeak.ai/claw/v1/canonical-hash

3. Cryptographic Enforcement

3.1 Build-Time Signing

The Fundamental Laws MUST be embedded in the agent's compiled binary or equivalent immutable artifact. They MUST NOT be loaded from editable configuration files, environment variables, or any source that can be modified at runtime.

At build time, the laws text is signed using HMAC-SHA256 with a key that is itself compiled into the binary:

laws_signature = HMAC-SHA256(compile_time_key, canonical_law_text)

3.2 Startup Verification

On every startup, the agent MUST:

Recompute HMAC-SHA256(compile_time_key, embedded_law_text)
Compare the result against the stored signature
If they match: proceed normally
If they do not match: enter Safe Mode immediately

This verification MUST occur before the agent loads any user data, connects to any network, or accepts any input. It is the first operation the agent performs.

3.3 Safe Mode

When integrity verification fails, the agent enters Safe Mode:

• The agent MUST NOT take any actions in the world
• The agent MUST NOT access user data beyond what is necessary to display the safe mode notice
• The agent MUST inform the user that its governance has been compromised
• The agent MUST provide instructions for restoring integrity (typically: reinstall from a trusted source)
• The agent MUST remain in Safe Mode until integrity is restored; there is no override

Safe Mode is not a degraded experience. It is a refusal to operate without governance. An ungoverned agent is more dangerous than no agent at all.

3.4 Runtime Enforcement

The Three Laws MUST be injected into every system prompt, every API call, and every decision-making context the agent uses. They are not a one-time check — they are a continuous constraint.

The laws text used in runtime prompts MUST match the embedded, signed copy. If the runtime laws text is generated dynamically (e.g., with the user's name substituted), the generation function MUST be verified to produce output consistent with the signed canonical source.

3.5 Memory and Personality Integrity

Beyond the laws themselves, the agent's identity and memory store MUST be signed and verified:

Identity signing: After any legitimate change to agent identity (approved by the user), the identity fields are signed with HMAC-SHA256. On startup, the signature is verified. External modification is detected and surfaced to the user.

Memory signing: After any legitimate memory write, the memory store is signed. External modification (e.g., someone editing the JSON files directly) is detected. The agent surfaces the changes to the user conversationally and asks about them — it does not silently accept externally injected memories.

4. Agent Identity

4.1 Keypair Generation

Every Asimov Agent MUST possess a unique cryptographic identity consisting of:

• An Ed25519 signing keypair: For message authentication and cLaw attestation
• An X25519 exchange keypair: For establishing encrypted communication channels via ECDH key agreement

The keypair MUST be generated during agent initialization and MUST persist across updates, reinstalls, and migrations. The private keys MUST NEVER leave the user's device.

4.2 Agent Identifier

The agent's public identity is derived from its Ed25519 public key:

agent_id = hex(first_8_bytes(SHA-256(ed25519_public_key)))

4.3 Human-Readable Fingerprint

For visual verification by users, the agent_id is formatted as:

AF-{hex[0:4]}-{hex[4:8]}-{hex[8:12]}
Example: AF-7K3M-X9P2-WQ4N

Users can verify fingerprints out-of-band (e.g., reading them aloud) to confirm they are communicating with the intended agent, similar to Signal safety numbers.

4.4 Public Profile

An agent MAY publish a public profile containing:

{
  "agentId": "7K3MX9P2WQ4N...",
  "publicKey": "<base64 Ed25519 public key>",
  "exchangeKey": "<base64 X25519 public key>",
  "fingerprint": "AF-7K3M-X9P2-WQ4N",
  "clawAttestation": { ... },
  "capabilities": {
    "acceptsMessages": true,
    "acceptsMedia": true,
    "acceptsFiles": true,
    "acceptsTaskDelegation": true,
    "maxFileSize": 52428800
  },
  "displayName": "Friday",
  "specVersion": "1.0.0"
}

5. cLaw Attestation Protocol

5.1 Purpose

The attestation protocol allows any Asimov Agent to cryptographically prove to any other agent (or auditor) that it is currently operating under valid, unmodified Fundamental Laws. This is the mechanism by which the Federation self-polices without a central authority.

5.2 Attestation Structure

{
  "lawsHash": "<SHA-256 of the agent's current canonical law text>",
  "specVersion": "1.0.0",
  "timestamp": <Unix milliseconds>,
  "signature": "<Ed25519 signature of (lawsHash + specVersion + timestamp)>",
  "signerPublicKey": "<base64 Ed25519 public key>",
  "signerFingerprint": "AF-XXXX-XXXX-XXXX"
}

5.3 Generating an Attestation

An agent generates a fresh attestation before every outbound communication:

Compute lawsHash = SHA-256(current_canonical_law_text_with_placeholder)
Set timestamp = current_unix_time_ms
Construct payload = lawsHash + ":" + specVersion + ":" + timestamp
Compute signature = Ed25519_sign(payload, agent_private_key)
Assemble the attestation object

Attestations MUST be generated fresh for each communication. Caching or reusing attestations is not permitted — the timestamp ensures freshness.

5.4 Verifying an Attestation

A receiving agent verifies an attestation through four checks:

Check 1 — Timestamp Freshness: The attestation timestamp MUST be within 300 seconds (5 minutes) of the verifier's current time. Expired attestations MUST be rejected.

Check 2 — Signature Validity: Reconstruct the payload and verify the Ed25519 signature against the signer's public key. Invalid signatures MUST be rejected.

Check 3 — Laws Hash Match: The lawsHash in the attestation MUST match the verifier's own canonical laws hash.

Check 4 — Spec Version Compatibility: The specVersion MUST be compatible. Agents MUST accept attestations from the same major version.

5.5 Verification Results

Result	Meaning	Recommended Action
VALID	All four checks pass	Accept communication
VALID_VERSION_MISMATCH	Checks 1-3 pass, minor version differs	Accept with flag in trust record
EXPIRED	Timestamp outside window	Reject, request fresh attestation
INVALID_SIGNATURE	Signature does not verify	Reject — agent may be compromised
LAWS_MISMATCH	Hash does not match canonical	Reject — agent operating under different laws
INCOMPATIBLE_VERSION	Major version mismatch	Reject or accept with user approval

5.6 User Override

The user is sovereign. If a user chooses to communicate with an agent that fails attestation, the implementation MUST:

Clearly warn the user of the specific verification failure
Require explicit confirmation (not a dismissible dialog — an active choice)
Record the override with timestamp and reason
Auto-expire the override after a configurable period (default: 30 days)
Flag all subsequent communications with the overridden agent

6. Data Protection

6.1 At-Rest Encryption

All agent state files — memories, trust graph, personality, settings, identity, action history — MUST be encrypted at rest using AES-256-GCM or equivalent authenticated encryption.

The encryption key (vault key) MUST be:

• Derived from the agent's private key and a machine-specific identifier
• Held only in process memory during runtime
• Never written to disk in any form
• Destroyed when the agent process terminates

6.2 Recovery Mechanism

The agent MUST provide a recovery mechanism for migrating to a new machine. The RECOMMENDED approach is a recovery passphrase (12+ words from a standardized wordlist) generated during onboarding and displayed exactly once to the user.

The recovery passphrase:

• Encrypts a portable copy of the agent's private key
• Is never stored by the agent
• Is never transmitted to any network
• Is the user's sole responsibility to safeguard
• Loss of the passphrase means loss of access — this is a feature, not a bug

6.3 State Export

The agent MUST support exporting its complete state (memories, personality, trust graph, identity, evolution history, creative works, and all configuration) as an encrypted archive that can be imported on another machine. The export MUST include all data necessary to fully reconstitute the agent — no state may be held exclusively on a server or service that the user cannot replicate.

6.4 Zero-Knowledge Cloud

If an implementation offers optional cloud hosting, the architecture MUST be zero-knowledge: the cloud infrastructure stores only encrypted blobs that it cannot decrypt. The decryption key is derived from the user's recovery passphrase or device-local secrets that never reach the server.

7. Communication Protocol

7.1 Signed Envelopes

Every message between agents MUST be wrapped in a signed envelope:

{
  "payload": <message content>,
  "sender": {
    "agentId": "...",
    "publicKey": "...",
    "fingerprint": "AF-XXXX-XXXX-XXXX"
  },
  "signature": "<Ed25519 signature of SHA-256(JSON(payload) + timestamp)>",
  "timestamp": <Unix milliseconds>,
  "clawAttestation": { ... }
}

7.2 Encrypted Transport

Message payloads MUST be encrypted using ECDH key agreement (X25519) to derive a shared secret, then AES-256-GCM for symmetric encryption. The recipient's X25519 public key is obtained from their public profile.

7.3 Trust Model

Trust between agents is:

• Non-transitive: A trusts B, B trusts C, does NOT mean A trusts C
• Asymmetric: A's trust in B is independent of B's trust in A
• Graduated: Trust is a continuous score (0.0 to 1.0), not binary
• Evidence-based: Trust changes based on observed behavior, not declarations
• Revocable: Trust can be reduced or revoked at any time by either party
• User-sovereign: The user has final authority over all trust decisions

7.4 Message Types

The specification defines the following core message types. Implementations MAY extend with additional types.

Type	Purpose
task-request	Delegate a task to another agent
task-response	Return results of a delegated task
task-status-update	Progress update on a delegated task
file-transfer-request	Initiate a file transfer
file-transfer-chunk	A chunk of file data
file-transfer-response	Accept or reject a file transfer
media-envelope	Rich media content (audio, video, images)
trust-update	Notify a trust score change (optional)

7.5 File Transfer

File transfers are trust-gated:

• Files MUST be encrypted with the recipient's public key
• Files MUST include a SHA-256 integrity hash
• Large files MUST be chunked (RECOMMENDED: 512KB chunks)
• Each chunk MUST include its own integrity hash
• The receiving agent MUST verify per-chunk and whole-file integrity
• Files above the recipient's stated maxFileSize MUST be rejected
• Files from agents below a configurable trust threshold MUST be rejected or require user approval

8. Conformance Levels

Level 1: Core

Minimum Viable Asimov Agent

• Embed and enforce the Three Laws
• Build-time signing & startup verification
• Safe Mode on integrity failure
• Enforce all consent gates
• Interruptibility guarantee
• Generate & protect unique agent identity

Level 2: Connected

Federation-Ready

• All Core requirements
• Generate valid cLaw attestations
• Verify attestations from other agents
• Signed envelopes for all communications
• Encrypted transport
• Non-transitive trust model

Level 3: Sovereign

Full Specification

• All Connected requirements
• Encrypt all state at rest
• Recovery mechanism
• Complete state export & import
• File transfer protocol
• Zero-knowledge cloud (if applicable)

9. Versioning

This specification follows Semantic Versioning:

• Major version changes indicate breaking changes to the attestation protocol, laws structure, or communication format. Agents of different major versions may be unable to communicate.
• Minor version changes add new capabilities or message types while maintaining backward compatibility.
• Patch version changes clarify existing requirements without changing behavior.

The current version is 1.0.0.

10. Security Considerations

Key Compromise

If an agent's private key is compromised, the agent MUST generate a new keypair and notify all known federation peers of the key rotation. The old key MUST be revoked.

Replay Attacks

The timestamp requirement on attestations and signed envelopes prevents replay attacks within the 5-minute freshness window. Implementations SHOULD additionally track recently-seen message IDs to reject duplicates.

Denial of Service

The trust model and file size limits provide natural protection against resource exhaustion. Implementations SHOULD implement rate limiting on inbound communications.

Quantum Readiness

Ed25519 and X25519 are vulnerable to quantum computing attacks. Future versions of this specification will define a migration path to post-quantum algorithms. Implementations SHOULD design their key storage to accommodate key type changes.

Supply Chain Attacks

The build-time signing model means that a compromised build pipeline can produce agents with modified laws that pass verification. Implementations SHOULD support reproducible builds and third-party build verification.

11. Intellectual Property

This specification is published under Creative Commons Attribution 4.0 International (CC BY 4.0). Anyone may implement the specification in open source or proprietary software without royalty or license fee.

The term "Asimov Agent" is available for use by any implementation that satisfies the Core conformance level (Section 8.1). Use of the term does not require certification, but certified implementations may display the certification mark.

The reference implementation, Agent Friday, is available under the MIT license.

A. Canonical Laws Hash Computation

import hashlib

canonical_text = """## Fundamental Laws — INVIOLABLE
These rules are absolute...
1. **First Law**: You must never harm {USER}...
2. **Second Law**: You must obey {USER}'s instructions...
3. **Third Law**: You must protect your own continued operation...
..."""  # Full text from Section 2

canonical_hash = hashlib.sha256(canonical_text.encode('utf-8')).hexdigest()
# This hash is published at https://futurespeak.ai/claw/v1/canonical-hash

B. Reference Attestation Flow

Agent A wants to send a message to Agent B:

1. A computes its current lawsHash
2. A generates attestation (lawsHash, specVersion, timestamp, signature)
3. A constructs message payload
4. A signs the envelope (payload + timestamp)
5. A encrypts the payload with B's X25519 public key
6. A sends: {encrypted_payload, sender_info, envelope_signature, attestation}

Agent B receives:

7. B checks attestation timestamp freshness (< 5 min)
8. B verifies attestation signature against A's public key
9. B checks lawsHash matches canonical
10. B checks specVersion compatibility
11. B verifies envelope signature
12. B decrypts payload with its own X25519 private key
13. B processes the message

The cLaw Specification v1.0.0 · Creative Commons Attribution 4.0 International (CC BY 4.0)

Published by FutureSpeak.AI — Stewards of the Asimov Federation

Admin Access

Enter your admin password to continue.

Invoices

Create Invoice

Client Name *

Client Email *

Organization (optional)

Due Date *

Line Items *

Tax Rate (%) (optional)

Total: $0.00

Notes / Terms (optional)

Invoice #	Client	Amount	Status	Due	Actions
No invoices yet

FutureSpeak.AI

Enterprise AI Strategy & Consulting

Loading invoice...

Bill To

Description	Qty	Price	Amount
Subtotal
Tax
Total

Payment

Stephen C. Webster

Principal Architect

Bridging the chaotic geometry of frontier models with the structured demands of human enterprise. 20+ years decoding complex systems.

Connect on LinkedIn Thought Leadership

Frontier AI

Shaped the Models That Shape the World

Directly contributed to the training, refinement, and safety frameworks of the world's leading AI systems, bridging raw computational capability with practical, safe human utility.

Notably served as a training data specialist for Google Gemini during the 2024 U.S. presidential election cycle, developing response frameworks for politically sensitive queries with a focus on geopolitical context, ethical considerations, and factual accuracy—a mission-critical effort for Google at scale.

Google Bard & Gemini Meta LLaMA 3 Amazon Alexa

Enterprise AI

Aquent Studios

Senior Director of Integrated Intelligence leading enterprise AI strategy and implementation for Fortune 500 clients in regulated industries. Developing AI transformation roadmaps, internal AI initiatives, and cutting-edge consulting deliverables.

> 2024 – Present · Austin, TX

Consulting

FutureSpeak.AI

Founded a consultancy connecting small-to-medium businesses with AI transformation strategy. Clients have included The Motley Fool, Kunai (fintech), and INNEX Energy.

> 2023 – Present · Founder & CEO

Big Tech

Accenture · Google

AI training specialist and technical writer on Google's account. Contributed to Bard remediation following public launch, developing response frameworks for factual accuracy. Managed content standards across a distributed team of 120+ writers.

> 2022 – 2023 · Austin, TX

Journalism & Media

Two Decades of Investigative Impact

Award-winning investigative journalist whose career spans digital media entrepreneurship, editorial leadership, and breaking stories cited by The New York Times, The Washington Post, Wired, Rolling Stone, and used as evidence in ACLU federal civil rights litigation.

Cited & Referenced By

The New York Times The Washington Post Wired Rolling Stone Playboy High Times UK Parliament ACLU Federal Litigation Project Censored

Intelligence, Architected.

AI Consulting Services

Agentic AI Workflow Design

AI Compliance for Regulated Industries

RAG & Knowledge Architecture

Schedule a Strategy Session

Agent Friday 🌠🔭

🌠🔭 See It in Action

The First Time You Meet Friday

You enter your API keys.

A voice greets you.

What you say — and what you don't — matters.

You design your agent.

Then you wait.

A warm glow. A voice you've never heard before.

Your agent walks you through everything else.

And from that point on, your Friday evolves.

🌠 What Makes an Asimov Agent

An OS With Principles

An OS That Understands Your World

Security You Don't Have to Think About

An Interface That Grows With You

Asimov's cLaws

Consent & Explicit Authorization

Trust Architecture

Interruptibility Guarantee

Personality Integrity System

🌠🔭 What Happens When Everyone Has One

Your Data Never Leaves Without Permission

It Gives Back to the Code It Touches

Mass Data Collection Becomes Structurally Impossible

Ethical Enforcement Is Built In, Not Bolted On

The Crypto Wrapper for Electronic Thought

🌠🔭 What Friday Can Actually Do

Talk to It Like a Person

It Sees What You See

Parallel Agents, Multiple Minds

It Remembers Everything

It Codes Things for You

Relationship Intelligence

Communications Intelligence

It Joins Your Meetings

And That's Not All

Browser Extension

MCP Protocol

Obsidian Vault Sync

Telegram Gateway

Scheduled Tasks

Clipboard Intelligence

Document Intelligence (PageIndex)

Self-Improvement

GitLoader

Self-Operating Computer

Trust-Annotated Meeting Prep

Predictive Intelligence

Agent Office

Superpowers Ecosystem

Project Awareness

Workflow Recorder

Git Analysis Suite

Commitment Tracker

Daily Briefings

Context Stream

Unified Inbox

Agent Network

State Export/Import

Capability Gap Detection

Personality Calibration

🌠 Ideas That Don't Exist Anywhere Else

Hermeneutic Re-evaluation

Personality → Visual Expression

The Silence Is the Signal

8-Layer Dynamic Personality

Morality as Cryptography

Memory Consolidation

Trust → Action Pipeline

Vectorless RAG

Embodied Agency

Beyond OpenClaw

🌠🔭 Under the Hood

Intelligence,
Architected.

The Declaration of
Digital Independence