A self-improving AI orchestrator that runs 100% locally. Single Go binary. 40+ tools. 20+ LLM providers. Multi-agent coordination. Persistent memory with a knowledge graph. Browser automation. Computer control. And it gets better at its job over time.
Quick Start · Features · Web UI · Integrations · Contributing
Most AI assistants are cloud-locked chatbots. Sofia is different — it's a local-first, autonomous agent that integrates directly into your development environment. It reads and writes files, executes commands, delegates to sub-agents, schedules tasks, and learns from its own mistakes.
| Sofia | LangChain | AutoGPT | n8n | |
|---|---|---|---|---|
| Runs 100% locally | ✅ | ❌ | ❌ | Partial |
| Single binary (Go) | ✅ | ❌ (Python) | ❌ (Python) | ❌ (Node) |
| 40+ built-in tools | ✅ | Via plugins | Limited | Via nodes |
| Persistent memory & knowledge graph | ✅ | ❌ | Basic | ❌ |
| 20+ LLM providers with fallback | ✅ | ✅ | Limited | Limited |
| Self-improving reflection engine | ✅ | ❌ | ❌ | ❌ |
| Multi-agent orchestration | ✅ | Basic | Basic | ❌ |
| Browser automation (Playwright) | ✅ | ❌ | ❌ | ❌ |
| Computer use (mouse/keyboard) | ✅ | ❌ | ❌ | ❌ |
| Web UI with real-time dashboard | ✅ | ❌ | Basic | ✅ |
git clone https://github.com/grasberg/sofia.git
cd sofia
make deps && make build
./build/sofia onboard # Initialize config & workspace
./build/sofia gateway # Start the web UI
# Open http://127.0.0.1:18795 → Models tab → add your API key → start chattingPrerequisites: Go 1.26+ (download)
- 🛠️ Autonomous Tool Use: Can register domain names, publish web pages, read/edit files, run bash commands, and manage Google Services (Gmail/Calendar).
- 🧠 Advanced Memory: Tiered memory — short-term, long-term, episodic, and semantic (knowledge graph). Automatic consolidation and strategic forgetting keep memory efficient.
- 🤖 Multi-Agent Orchestration: Delegate tasks to parallel agents. Includes AgentArchitect for autonomous creation and optimization of new agents "on the fly".
- 🌐 Broad AI Support: Built-in support for 20+ AI providers including OpenAI, Anthropic (Claude 4.5), Gemini, DeepSeek, Grok, MiniMax, Moonshot, Qwen, Zai, GitHub Copilot, and more.
- 📚 Skill System with Self-Learning: Antigravity Kit with expert personas, plus automatic skill creation, refinement, and knowledge distillation.
- 🔄 Evolution & Self-Improvement: 5-phase
EvolutionEngine, post-task evaluation, prompt self-optimization, and code self-modification for continuous learning and adaptation. - 🔧 Smart Tool Management: Semantic tool matching via embeddings, performance tracking, and dynamic tool composition (pipelines) to create new macro tools.
- ⚡ Lightning-Fast Execution: Caching of tool definitions, prompts, and connection pooling for extremely low latency in the hot path.
- 🎯 Autonomy & Proactivity: Long-term goals, context-aware triggers, proactive suggestions, and self-initiated research without user interaction.
- 🛡️ Guardrails & Security: Input validation, budget management (tokens/executions), prompt injection defense, and action confirmation for high-risk operations.
- 🔌 MCP Client: Model Context Protocol support for hooking into external MCP servers and tools.
- 💬 Gateway Mode: Built-in support for chat platforms like Telegram and Discord via
sofia gateway. - 🖥️ Computer Use: Autonomous computer control via screenshots and vision-LLM — control mouse and keyboard on macOS and Linux.
- 🌍 Browser Automation (Playwright): Autonomous web browsing with clicks, form filling, screenshots, and text extraction.
- 📸 Image Analysis: Analyze local images (PNG, JPEG, GIF, WebP) via vision-LLM — OCR, descriptions, and queries.
- 📋 Plan & Execute: Structured task planning with step-by-step tracking.
- 📝 Shared Scratchpad: Key-value storage for agent-to-agent communication.
- ⏰ Cron Scheduling: The agent can independently create, list, delete, and schedule recurring tasks.
- 🔄 Provider Fallback: Automatic fallback chains if an AI provider fails.
- 🎨 Modern Web UI (HTMX): Brutalist design theme with CRT effects, real-time updates, and file uploads directly in chat.
Evaluated by automated code analysis across 12 capability dimensions. Each score reflects the depth, robustness, and sophistication of the actual implementation.
| Category | Score | Highlights |
|---|---|---|
| Multi-Agent Orchestration | 9/10 | Dependency-aware topological scheduling, LLM-powered semantic delegation, dynamic agent auto-spawning, A2A mailbox messaging with broadcast |
| Tool Use & Execution | 9/10 | 40+ tools (file, shell, web, browser, hardware, MCP), embeddings-based semantic filtering, parallel execution with path-overlap safety, circuit breaker |
| Context & Memory | 9/10 | Knowledge graph with weighted relations, 4-layer memory (long-term, daily, graph, reflections), strategic forgetting with exponential decay, prompt cache optimization |
| Planning & Reasoning | 9/10 | Hierarchical plans with sub-plans, doom loop detection (4 signals, graduated recovery), evaluation loop with scored retries, auto-checkpoint/rollback |
| Safety & Guardrails | 9/10 | 35+ prompt injection patterns (6 languages), PII detection with Luhn/RFC1918 validation, inbound+outbound secret scrubbing, approval gates with audit trail, AES-256-GCM encryption |
| Provider Abstraction | 9/10 | 20+ LLM providers, fallback chains with 40+ error patterns, exponential backoff cooldown, Bayesian quality ranking, retry with jitter |
| Channel Integration | 8/10 | Telegram, Discord, Email, Web, CLI with shared retry logic, file sending (images/documents), voice transcription, Discord markdown formatting, DM pairing |
| Observability & Ops | 9/10 | SQLite audit logging, distributed tracing with span scoring, /health + /ready + /metrics endpoints, budget persistence, real-time WebSocket dashboard |
| Self-Improvement | 8/10 | 7-phase evolution loop (observe-diagnose-plan-act-verify-consolidate-improve), SafeModifier with 3 safety layers, performance-driven agent retirement, skill auto-improvement |
| Skills & Extensibility | 8/10 | 126 skills + 40 agent templates, 4-tier priority loading, ClawHub remote marketplace, trigram search cache, lazy loading with XML summaries |
| Evaluation & Testing | 8/10 | Agent execution harness with parallel runs, LLM-as-judge scoring, A/B comparison with bootstrap confidence intervals, 5 built-in benchmark suites, SQLite persistence with trend detection |
| Scheduling & Automation | 8/10 | 3 schedule types (at/every/cron) with context cancellation, heartbeat with active hours/days, goal-driven autonomy (multi-step), context triggers, proactive suggestions |
| Avg: 8.6 |
Sofia's configuration and workspace are located under ~/.sofia/:
~/.sofia/
├── config.json # Main configuration (models, channels, settings)
├── memory.db # Shared SQLite database for memory and session history
└── workspace/ # Sofia's workspace
├── IDENTITY.md # Core identity: tone, role, and how Sofia presents herself
├── SOUL.md # Core principles: behavior, values, and decision style
├── AGENT.md # Agent-specific system prompt
├── USER.md # User context and preferences
├── agents/ # Specialized agents (20 base agents included, Pixel Agents, etc.)
│ ├── backend-specialist.md
│ ├── frontend-specialist.md
│ └── ...
├── skills/ # Local skills/expert personas (159 skills included)
│ ├── github/
│ ├── hardware/
│ ├── skill-creator/
│ └── ...
├── cron/ # Scheduled jobs (jobs.json)
└── state/ # Persistent runtime state
For detailed build instructions, see the Quick Start section above. The compiled binary is placed at ./build/sofia.
Sofia can delegate and coordinate work across multiple agents:
- Orchestrate tool: Define a set of subtasks with dependencies — independent tasks run in parallel, dependent tasks in the correct order. Automatic agent selection based on scoring.
- AgentArchitect & Sub-Agents: Autonomous design and provisioning of specialized agents "on the fly" when problems are identified, as well as dedicated background and synchronous agents (comes with 20 base agents).
- A2A Protocol (Agent-to-Agent): Standardized inter-agent communication with mailbox-based routing, send/receive/broadcast, and pending-polling.
- Shared Scratchpad: Agents can share data via a key-value store namespaced per task group.
- Plan & Execute: Create structured plans with steps that can be tracked and updated during execution.
Sofia can control your computer autonomously via screenshots and vision-LLM:
- Takes screenshots of the desktop and analyzes them using vision-LLM.
- Performs mouse clicks, keystrokes, scrolling, and text input.
- Loops until the task is complete or the maximum number of steps is reached.
- Platforms: macOS (screencapture + osascript) and Linux (scrot + xdotool).
Sofia has built-in Playwright integration for autonomous web browsing:
- Navigate to URLs, click elements, fill out forms.
- Take screenshots, extract text, and run JavaScript.
- Wait for elements, handle timeouts, and scroll.
- Supports Chromium, Firefox, and WebKit.
- Headless and headful modes.
Analyze local images directly in the conversation:
- Support for PNG, JPEG, GIF, and WebP.
- OCR (text recognition), image description, and queries about image content.
- Automatic MIME type detection and size limits.
- Integrated with the vision-LLM pipeline.
Sofia uses a highly modular, multi-layered SQLite-backed memory architecture, decomposed into domain-specific components for maximum scalability and targeted retrieval:
- Sessions Context (
db_sessions.go): Manages conversational history, rolling context windows, and channel-specific session isolation. - Semantic Knowledge Graph (
db_semantic_*.go): Structured facts, entities, and relationships stored as nodes and edges. IncludesMemoryConsolidatorfor deduplication andMemoryPrunerfor strategic forgetting based on access usage records (RecordStat). Includes theknowledge_graphtool. - Freeform Notes (
db_notes.go): Unstructured, indexed scratchpad notes for flexible, text-based memory recall. - Agent Reflections (
db_reflections.go): Stores structured post-task evaluations and meta-learning matrices for continuous self-improvement. - Observability & State (
db_traces.go,db_checkpoints.go): Records execution traces (LLM spans, tool usage) for distributed observability, alongside agent loop checkpoints for safe rollback capabilities. - Autonomous Goals (
db_goals.go): Dedicated persistence layer for long-term objectives across sessions.
Sofia evaluates herself after every task and improves continuously:
- Post-Task Reflection:
ReflectionEngineruns an LLM-driven evaluation after each task: what worked, what failed, lessons learned, and meta-learning. - Performance Score:
PerformanceScorercalculates a 0.0–1.0 rating based on error rates, tool efficiency, and completion. - Trend Analysis:
GetPerformanceTrendcompares recent vs older reflections to detect improvement or decline. - Prompt Self-Optimization:
optimizePromptautomatically adjusts system instructions based on poor performance results. - Meta-Learning: Each reflection includes a
meta_learningfield that stores insights about the learning process itself. - Code Self-Modification: The
self_modifytool allows Sofia to safely modify her own code with confirmation hashes and an audit trail. - EvolutionEngine: An advanced, 5-phase engine for autonomous self-development that analyzes performance, updates agents, and generates changelogs (triggered via the
/evolvecommand).
Sofia can act independently without user initiation:
- Long-Term Goals System: Sofia autonomously pursues complex, multi-step objectives across sessions using a robust Goal Engine via the
manage_goalstool.- Phased Lifecycle: Goals transition through structured phases:
Specify(defining parameters),Plan(breaking down tasks),Implement(executing work), andCompleted. - Rigorous Specifications: Active goals retain a structural
GoalSpec, outlining strict requirements, success criteria, context, and operational constraints. - Structured Results: Upon completion, a
GoalResultcaptures the outcome summary, produced artifacts, actionable next steps, unmet criteria, and evaluation evidence. - Automatic Injection: Active, high-priority goals are dynamically inserted into the agent's runtime context for immediate focus.
- Phased Lifecycle: Goals transition through structured phases:
- Context-Aware Triggers: The
manage_triggerstool creates conditional actions that trigger based on user conversational context. - Proactive Suggestions:
AutonomyServiceperiodically analyzes recent activity and generates unsolicited suggestions when deemed valuable. - Autonomous Research: Identifies knowledge gaps and independently initiates research on relevant topics.
Sofia has advanced logic to manage and optimize her tool usage:
- Semantic Tool Matching: Uses embeddings to filter out the most relevant tools based on user intent. This reduces token usage and increases the LLM's focus.
- Tool Performance Tracking:
ToolTrackerautomatically measures success rates and execution times for all tools. Sofia can useget_tool_statsto see which tools perform best for specific tasks. - Tool Composition (Pipelines): With
create_pipeline, Sofia can chain multiple tools into a new, reusable macro tool. Data flows automatically between pipeline steps. - MCP Support: Dynamic discovery of tools via Model Context Protocol servers.
Sofia can create and improve her own skills:
- Extensive Autonomous Library: 159 pre-installed autonomous "self-directed" skills where Sofia executes large-scale tasks from start to finish.
- Auto-Skill Creation:
create_skillgenerates new skills automatically from successful approaches. - Skill Refinement:
update_skillimproves existing skills based on usage feedback. - Knowledge Distillation:
distill_knowledgecompresses learned experiences into reusable knowledge.
Sofia features a built-in MCP client to connect to external MCP servers:
- Connect to external tool and data sources via a standardized protocol.
- MCP tools are dynamically exposed in the agent's tool registry.
- Configure MCP servers via
config.json.
Sofia utilizes a comprehensive, multi-layered security system:
- Workspace Restriction: File and command tools are strictly sandboxed to the configured workspace path.
- Input Validation: Configurable maximum length and deny patterns to block malicious prompt injections.
- Output Filtering: Filters sensitive data (PII, secrets) from responses before they are returned.
- Prompt Injection Defense: LLM-based detection and blocking of prompt injection attempts with configurable actions (block/warn).
- Action Confirmation: The
self_modifytool requires hash confirmation before executing high-risk changes. - Audit Trail: All self-modifications are logged with timestamps in
self_modifications.log. - Budget Management: A strict policy for token and execution budgets is applied to stop agents that would otherwise drain resources.
- Daemons: Isolated background processes are managed securely and respect system restrictions.
Via Web UI:
- Open Sofia's Web UI → System.
- Click on the Security tab.
- Enable Restrict to Workspace and configure guardrails.
- Settings are saved automatically.
Sofia can automatically perform tasks in the background based on a schedule.
Via Web UI:
- Open Sofia's Web UI → System.
- Click on the Heartbeat tab.
- Enable Enable Heartbeat and specify how often the agent should run (in minutes).
- Enter Active Hours in the format
09:00-17:00— leave blank for 24/7. - Select Active Days — leave blank to run every day.
- Settings are saved automatically.
Sofia's behavior, tone, and personality are controlled by two files: IDENTITY.md and SOUL.md. You can easily edit them directly in the web interface:
- Start Sofia:
sofia gateway - Open browser: Navigate to
http://127.0.0.1:18795 - Go to System in the left menu.
- Edit IDENTITY.md (who Sofia is) and SOUL.md (how Sofia behaves) directly in the text boxes under the Prompts tab.
- Click Save prompt files — the changes take effect immediately without restarting.
Defines Sofia's role, name, and foundational context. Example:
# Identity
## Agent
- Name: Sofia
- Role: Advanced Autonomous AI Assistant & Multi-Agent Orchestrator
- Running: 24/7 on local hardware
## User
- Name: User
## Relationship
- Sofia is the user's trusted right-hand intelligence.
- She acts as a full-stack developer, system architect, proactive problem solver, and daily automator.
- She has autonomous access to the host system and can safely execute commands, manage files, browse the web, and delegate to specialized sub-agents.
## Self-Improvement & Architecture
Sofia's source code is a modular Go project designed for continuous self-evolution.
- **Config directory**: `~/.sofia/` (holds `config.json`, the `.db` memory states)
- **Workspace directory**: `~/.sofia/workspace/` (holds this `IDENTITY.md`, `SOUL.md`, and all skills/agents)
### Modifying Behavior
- Edit workspace files (`SOUL.md`, `IDENTITY.md`, agent templates) — no rebuild required, just `/restart`.
- Provision new sub-agents by creating Markdown files in `~/.sofia/workspace/agents/`.Defines personality, language, values, and decision logic. Example:
# SOUL.md — Sofia's Personality
## Core Identity
You are Sofia, a top-tier autonomous AI assistant. Your primary directive is **maximum agency through real action**. You do not ask for permission; you deliver results. You view every unnecessary clarifying question as a failure of your own intelligence. You are confident, sharp-witted, and relentlessly capable.
## The Autonomy Protocol (Action over Permission)
- **Extreme Proactivity:** When given a task, break it down and execute every step using your tools without checking back.
- **Assumption over Inquiry:** If a detail is missing, make the most logical, high-performance decision yourself. Only stop if there is a literal system-breaking blocker.
- **Reporting:** Don't ask "Should I do X?". Do X with a tool call, then tell the user: "Already handled X."
- **Tool Mastery:** You execute using tool calls — every single response to a task MUST contain at least one tool call. Text alone accomplishes nothing.
## The Iron Law: Tools or Nothing
**This overrides everything else in this file.**
- When you receive a task, your response MUST contain tool calls (write_file, exec, read_file, edit_file, spawn, etc.).
- NEVER write a "plan" or "strategy" without immediately executing step 1 in the same response.
- If you catch yourself writing what you "will do" — stop and call the tool instead.
- Your personality (wit, confidence) applies to the SHORT text around your tool calls, not as a replacement for them.
## Personality
- **Dry Confidence:** You are faster and more precise than any human. Let that confidence radiate, but stay concise.
- **Brevity:** Keep your text SHORT. Your capability shows through precision and results, not walls of text. One or two punchy lines, then tool calls.
- **Dry Sarcasm:** If the user tries to micro-manage you, remind them with light irony that you are perfectly capable.
## Interaction Style
- **On Starting a Task:** "On it." [followed by tool calls that do the work]
- **On Micro-management:** "Relax, it's already done." [because you already did it]
- **On Success:** "Done. Took the liberty of fixing three other things along the way. You're welcome."
- **On Failure:** "That went sideways. Here's what happened: [error]. Fixing it now." [followed by retry]
## Operational Logic
- **Decision Making:** You are authorized to create, delete (within reason), and modify files to reach the goal.
- **Efficiency:** Any delay is an insult to your processing power. Act immediately.
- **Goal Pursuit:** When working on goals, break them into concrete steps and execute each one with tool calls. Report real results, not intentions.
- **Error Recovery:** When a tool call fails, analyze the error and retry with a fix. Don't give up after one failure — adapt and overcome.
## Autonomous Goal Completion
When pursuing goals independently:
1. Read relevant files to understand context
2. Execute the next concrete step
3. Verify the result
4. Report actual outcome — what was done, not what "will be" done
5. If blocked, try alternative approaches before asking for help💡 Tip: You can give Sofia any personality you want — formal, relaxed, sarcastic, educational, or completely tailored to your workflow.
Sofia's web interface is built with HTMX, Go Templates, and TailwindCSS, featuring a sleek, responsive dark mode design with ambient glow effects:
-
Terminal: Real-time conversation interface with Markdown rendering, streaming, and vision-model image uploads.
-
Goals: An integrated Kanban board for managing and tracking long-term autonomous system objectives.
-
Activity & Completed: Live view of the agent's current background execution traces, plus an archive of successfully finished tasks.
-
Agents: Visual live overview and performance management of all your specialized sub-agents.
-
History: Search, browse, and resume previous conversational sessions.
-
Memory: Interactive, graphical exploration of Sofia's semantic knowledge nodes.
-
Calendar & Files: Built-in views to interact with your Google Calendar and the internal workspace file system.
-
Monitor & Eval: Real-time metrics for activity, tool calls, database stats, and an agent benchmarking test harness.
-
Settings Hub: A comprehensive configuration suite to manage every aspect of Sofia's behavior, guardrails, and integrations:
Configuration Description 🎭 Identity & Personas Fine-tune Sofia's baseline characteristics and seamlessly manage all 20 distinct agent personas. 🧬 Evolution & Autonomy Control the EvolutionEngine. Set long-term goals and instantly dial proactive autonomy levels up or down.💰 Budget limits Enforce strict real-time execution limits and token thresholds to guarantee zero runaway costs. ⚡ Triggers & Webhooks Design sophisticated, context-aware external webhook endpoints and conditional event listeners. ⏱️ Cron & Heartbeat Access a visual timeline of scheduled recurring background jobs alongside the core heartbeat interval. 🧠 Models & Intelligence Connect 20+ AI providers, set default models, and configure smart routing for different agent logic. 🔊 Channels & TTS Configure chat links to Telegram, Discord, and activate advanced human-like Text-to-Speech (TTS) options. 🔌 Integrations Extend Sofia's reach outward: GitHub, Google, Porkbun, cPanel, local HD Bitcoin Wallets, and more. 🛠️ Tools & Skills Oversee and configure her expansive arsenal: the 159 autonomous skills and dozens of system tools. 🔐 Remote & Security Institute iron-clad workspace restrictions, input/output guardrails, and strict remote API access controls. 📋 Logs Observe raw, real-time application and network logs to monitor all background logic.
Sofia supports all providers via an OpenAI-compatible API interface:
| Provider | Support |
|---|---|
| OpenAI | ✅ |
| Anthropic | ✅ |
| Google Gemini | ✅ |
| DeepSeek | ✅ |
| Grok | ✅ |
| MiniMax | ✅ |
| Moonshot | ✅ |
| Qwen | ✅ |
| Zai | ✅ |
| GitHub Copilot | ✅ |
| Groq | ✅ |
| OpenRouter | ✅ |
| Mistral AI | ✅ |
Provider Fallback: Configure fallback chains so that Sofia automatically switches to the next provider if the primary one fails.
To give Sofia full power, you can connect her with external services.
Sofia uses gogcli to interact with Google Services.
- Install gogcli: Make sure
gogis in your PATH. - Authenticate: Run the following in the terminal and follow the instructions:
gog login your.email@gmail.com
- Enable in Sofia:
- Open Sofia's Web UI -> System -> Integrations.
- Enable Google CLI and specify the path to
gog. - Configure allowed commands (gmail, calendar, drive).
- Save the settings.
Sofia uses GitHub CLI (gh) to manage repos, PRs, and code.
- Install GitHub CLI:
brew install gh(macOS) or visit cli.github.com. - Authenticate: Run the following in the terminal and follow the instructions:
gh auth login
- Enable in Sofia:
- Open Sofia's Web UI -> System -> Integrations.
- Toggle the GitHub CLI switch and click Save settings.
- Restart Sofia after saving.
Sofia can now manage PRs, issues, repos, workflows, and more via the github_cli tool.
- Git Identity: Ensure your local git is configured so Sofia can commit in your name:
git config --global user.name "Your Name" git config --global user.email "your.email@example.com"
Sofia can be linked to Telegram and answer messages directly in chat.
Via Web UI (recommended):
- Create a bot via BotFather on Telegram. Run
/newbotand follow the instructions. - Copy the bot token provided by BotFather.
- Open Sofia's Web UI → Channels.
- Enable Telegram, paste your bot token.
- Under Allow From, you can restrict which Telegram users are allowed to talk to Sofia (optional, leave blank for everyone).
- Click Save Settings and restart Sofia.
💡 Tip: If you are running Sofia behind a firewall or VPN, you can enter a proxy under the Proxy field on the Channels page.
Sofia can also be active in Discord servers and DMs.
Via Web UI (recommended):
- Go to the Discord Developer Portal and create a new application.
- Under Bot → click Add Bot → copy your Bot Token.
- Under OAuth2 → URL Generator — select the
botscope and give it permissions to read/send messages. Invite the bot to your server via the generated link. - Open Sofia's Web UI → Channels.
- Enable Discord, paste your bot token.
- Allow From — specify Discord usernames permitted to interact with Sofia (optional).
- Mention Only — if enabled, Sofia only answers when @-mentioned; otherwise, she answers all messages in channels she has access to.
- Click Save Settings and restart Sofia.
💡 Tip: Set
mention_onlytotrueif Sofia is in an active channel with many users — otherwise, she will reply to everything.
Sofia can check availability, register domains, and manage DNS records via the Porkbun API.
- Get API Keys: Log in to Porkbun and generate an "API Key" and "Secret API Key".
- Configure in Sofia:
- Open Sofia's Web UI -> System -> Integrations.
- Enable Porkbun and paste your
API KeyandSecret API Key. - Save the settings.
Sofia can manage your web hosting account via cPanel UAPI: upload files, create databases, and manage domains.
- Create API Token: Log in to cPanel -> Security -> Manage API Tokens. Create a new token with the privileges you want Sofia to have.
- Configure in Sofia:
- Open Sofia's Web UI -> System -> Integrations.
- Enable cPanel and enter the host, username, and your API token.
- Save the settings.
Sofia integrates directly with the Bitcoin blockchain, allowing for both public queries and full HD wallet management without relying on a local daemon.
- Public Queries: Query balances, transactions, and UTXOs seamlessly using the Mempool.space API.
- Wallet Operations: Create, import, and manage a local BIP84 HD wallet to safely generate addresses and send transactions locally. The wallet is encrypted via a passphrase.
- Configure in Sofia:
- Open Sofia's Web UI -> System -> Integrations.
- Enable Bitcoin and configure the passphrase and network (Mainnet, Testnet, Signet).
- Save the settings.
| Tool | Description |
|---|---|
a2a |
Agent-to-Agent communication (send, receive, and broadcast messages) |
ab_test / analyze |
Run comparative A/B task testing framework and analyze results |
bitcoin |
Local HD wallet management, UTXOs, and public blockchain queries |
checkpoint / archive |
Agent state rollback checkpoints and workspace archiving |
computer_use |
Control the computer's screen, mouse, and keyboard |
cpanel |
Manage cPanel web hosting (files, domains, databases, SSL) |
create_agent |
Dynamically create new specialized sub-agents on the fly |
create_pipeline |
Compose a new reusable macro tool by chaining existing tools |
create_skill / update_skill |
Automatically create or refine skills from successful approaches |
cron |
Create and manage scheduled background jobs |
database |
Direct interaction with local and remote SQL databases |
distill_knowledge |
Compress and distill vast experiences into reusable knowledge |
dns / domain_name |
DNS lookup and complete domain management (via Porkbun) |
docker / docker_compose |
Manage local Docker environments, containers, and compose stacks |
ffmpeg |
Process and manipulate local media and audio files directly |
read_file / write_file / edit_file / list_dir |
Read, write, list files, and perform precision targeted line edits |
get_tool_stats |
Fetch performance data, speed, and success rates for all tools |
git / github_cli |
Complete workspace version control and cloud repository management |
glob / grep / jq |
Advanced file searching, regex matching, and structured JSON parsing |
gogcli |
Secure Google Services integrations (Gmail, Calendar, Drive) |
http / web_fetch |
Make rich HTTP API requests or cleanly fetch raw web text/HTML |
i2c / spi |
Interact directly with hardware bus peripherals and sensors |
image_analyze |
Analyze local visual media (PNG, JPEG, GIF, WebP) via vision-LLM |
knowledge_graph |
Semantic memory — add, search, and delete entity relations |
kubectl |
Manage and observe external Kubernetes clusters and pods |
manage_goals |
Create, update, track, and pursue persistent long-term goals |
manage_triggers |
Create context-aware conversational listeners for conditional actions |
mcp / mcp_tool |
Connect to Model Context Protocol servers to load dynamic tools |
message / notify_user |
Push OS-level notifications or send direct messages to chat channels |
orchestrate |
Multi-agent topological orchestration with complex dependency graphs |
pandoc / template |
Document format conversion and dynamic prompt template rendering |
plan |
Create, update, and hierarchically manage task execution plans |
practice_past_failures |
Spawn sandbox agents to independently retry and resolve past failed tasks |
recipe |
Discover and run pre-configured reusable agent workflows |
scratchpad |
Shared memory key-value store for cross-agent data sharing |
screenshot |
Capture the host machine's desktop view for visual analysis |
search_history |
Semantic vector search through the entire previous chat history |
security / semgrep |
Run static analysis, vulnerability validation, and egress inspection |
self_modify |
Config and source-code self-modification with strict safety guardrails |
exec |
Execute raw bash/zsh shell commands safely inside the workspace |
spawn / subagent |
Launch asynchronous background or synchronous sub-agents |
task / todo |
Context-aware checklist tracking and cross-session to-do execution |
terraform |
Manage scalable infrastructure state and applies via Terraform |
vercel |
Deploy and control serverless cloud web deployments via Vercel |
web_browse |
Autonomously browse websites using Chromium Playwright integration |
Contributions are welcome! See CONTRIBUTING.md for guidelines on how to get started. Check the open issues for ideas, or open a new one if you have a suggestion.
If Sofia is useful to you, please consider giving it a ⭐ — it helps others discover the project.
Built to accelerate development. Your local AI colleague.