Autonomy
Self-Harness/Self-Directed AI Agent Core Under Development
Last verified:
What is Autonomy?
Autonomy is a self-directed AI agent system that runs goal-based task loops with minimal or no human intervention. It starts from a goal, selects relevant skills, proposes candidate action paths, ranks them, executes approved actions through a controlled gateway, and evaluates outcomes so it can continue toward completion.
The system is built around an AgentLoop that advances step by step through a fixed turn structure. It supports interactive mode and batch mode, records all events by run_id in AutonomyStore, and uses event sourcing so runs can be replayed later. The website presents this as a practical agent core rather than a simple chat interface, with a strong emphasis on control, traceability, and bounded execution.
A major focus is safe and auditable execution. Every tool call goes through ActionGateway and ApprovalPolicy, and each action carries a risk level, expected effect, and verification plan. The site also says the system can stop cleanly on outcomes like achieved, blocked, no candidates, approval denied, max steps reached, or failed, which prevents endless loops.
Autonomy appears aimed at developers, AI agent builders, and technically advanced users who want a framework for autonomous workflows, skill reuse, and iterative learning. It includes bundled skills, a terminal UI, local and OpenAI-compatible provider support, MCP tool integration, memory tools, and database tools, making it suitable for experimentation, internal automation, and agent infrastructure work.
Autonomy pricing
Pricing model: Freemium
The website does not list any pricing, free tier, or paid plan details. It presents Autonomy as a framework you can clone from GitHub and install locally with development dependencies, which suggests an open-source style setup rather than a hosted subscription product. No credits, usage limits, enterprise tiers, or included plan features are described on the page.
Autonomy pros
- Goal-driven autonomous loop
- No manual intervention required
- Fixed step-by-step turn flow
- Interactive mode support
- Batch mode support
- Detailed run logging
- Event-sourced execution history
- Replayable runs
- Controlled tool execution gateway
- Approval-based action handling
- Risk levels for actions
- Expected effect tracking
- Verification plan for each action
- Candidate path ranking
- Beam search style selection
- Deterministic failure handling
- LLM-assisted outcome evaluation
- Bundled procedure skills
- Automatic skill selection
- Learning loop for new skills
- Recipe promotion from successful actions
- Background skill curation
- Skill merge automation
- Terminal UI included
Autonomy cons
- Requires technical setup
- Not a consumer-friendly app
- Uses a command-line workflow
- Depends on model/provider configuration
- Some tools require approval
- May refuse unknown shell commands
- Limited by max step caps
- Learning proposals still need review
- Background curation may add complexity
- Best suited to advanced users
Frequently asked questions about Autonomy
What is Autonomy?
Autonomy is a self-directed AI agent framework that turns a goal into a managed execution loop. It selects relevant skills, generates candidate actions, ranks them, executes approved actions, and evaluates the result before continuing. The website frames it as an autonomous system for building reliable agent workflows rather than a chat-only assistant.
How does the agent loop work?
The AgentLoop starts with a goal and advances through repeated turns until the goal is achieved, the system is blocked, or the step limit is reached. Each turn follows a fixed flow: select skills, generate candidate routes, rank them, execute through the gateway, and evaluate the outcome. That structure is meant to keep the system predictable and prevent uncontrolled looping.
What happens when an action is unsafe or uncertain?
Actions must pass through ActionGateway and ApprovalPolicy before execution, and each one carries a risk level plus a verification plan. Low-risk actions can be handled automatically, while higher-risk actions such as writing or browser-related steps may require approval. If the system cannot proceed safely, it can stop with an approval denied or blocked outcome.
Does Autonomy learn from successful runs?
Yes. The website says successful runs can trigger learning, including drafting new procedure skills when there are enough successful steps. It also describes recipe promotion, where repeated successful actions can be elevated into reusable candidate recipes for future runs.
What skills does Autonomy include?
The site says the ProcedureSkillLibrary includes 15 bundled skills. These cover tasks such as API debugging, browser navigation, code editing, codebase documentation, planning, process management, systematic debugging, technical spikes, TDD, website inspection, writing plans, database retrieval, and email-related work.
Can I use my own AI provider?
Yes. The page says Autonomy supports local Ollama models as well as multiple OpenAI-compatible providers. It also mentions provider configuration and API key management, so users can connect the framework to different model backends.
Does Autonomy support external tools?
Yes. It supports MCP tools imported through mcp_servers.yaml, and those tools are managed through the same registry and gateway flow as other actions. The page also lists file, terminal, search, skills, memory, and database toolsets as part of its broader tool environment.
How is execution tracked?
Every run is recorded in AutonomyStore using event sourcing. The page describes a full sequence of events such as run_started, skills_selected, candidates_ranked, action_selected, approval_decision, observation, outcome_evaluated, recipe_learned, learning_review, and run_finished. That makes runs auditable and replayable.
What is the terminal UI for?
The autonomy tui provides a richer terminal-based interface for monitoring sessions, turns, action trails, and display modes. The page says natural language still flows into the AgentLoop, while the UI does not directly execute tools. It is mainly a control and visibility layer for operators.
Who is Autonomy for?
Autonomy is aimed at developers and advanced users who want a controllable self-directed agent core. It is especially relevant for people building agent infrastructure, workflow automation, or reusable skill systems. The page does not position it as a simple no-code product for casual users.