Runtime harness, not just prompts
Agiwo centers execution control, orchestration, observability, and optimization loops instead of treating the runtime as an afterthought.
Runtime harness for AI systems
Build orchestrated, self-improving agents with explicit runtime control.
Agiwo combines agent execution, tool contracts, scheduler orchestration, persistence, tracing, and a control plane into one Python runtime harness. It is designed for teams that need more than prompt wrappers and less hidden runtime behavior.
Why Agiwo
Agiwo is for teams that need runtime truth, not just generation output.
The project is shaped around orchestrated and self-improving agent systems: explicit boundaries, persistent state, traceable execution, and a clear path from SDK usage to control-plane operations.
Explicit orchestration
Agents, tools, scheduler, storage, and Console stay separate enough to inspect, debug, and evolve independently.
Built for persistent systems
The scheduler model handles persistent roots, child agents, waiting, wake conditions, and steering without inventing a second runtime.
Ready for improvement loops
Skills, memory, traces, context optimization, and operator visibility make iterative self-improvement practical instead of aspirational.
Quick example
Start with a minimal Python agent, then grow into orchestration.
The same runtime surface supports one-shot execution, streaming output, tools, and scheduler-managed workflows. Start small without painting yourself into a corner.
import asyncio
from agiwo.agent import Agent, AgentConfig
from agiwo.llm import OpenAIModel
async def main() -> None:
agent = Agent(
AgentConfig(
name="assistant",
description="A helpful assistant",
system_prompt="You are a concise assistant.",
),
model=OpenAIModel(name="gpt-5.4"),
)
result = await agent.run("Summarize why runtime control matters for AI agents.")
print(result.response)
await agent.close()
asyncio.run(main())
Choose your path
Move from evaluation to implementation without guessing where to go next.
The docs are organized around the decisions external developers usually make: first run, orchestration design, and operator-facing deployment.
Start your first agent
Install Agiwo, configure a provider, and run a minimal agent before you add tools or orchestration.
Build the first agentBuild orchestration
Learn scheduler patterns, persistent roots, child agents, and runtime control for long-lived workflows.
Explore multi-agent patternsOperate with Console
Understand sessions, scheduler state, traces, and Docker deployment for self-hosted operator workflows.
See the control planeArchitecture
Keep runtime boundaries visible as the system grows.
The harness story is not one abstraction. It is the combination of agent execution, tool contracts, orchestration, observability, and operator-facing control surfaces.
Agent
Owns prompts, execution, hooks, runtime context, and the canonical run loop.
Tool Surface
Defines stable contracts for builtin tools, custom tools, skills, and nested-agent adapters.
Scheduler
Coordinates persistent roots, child execution, wait states, wake conditions, and routing.
Storage & Trace
Persist runs, steps, and traces so runtime state can be inspected instead of inferred.
Console
Projects runtime state, sessions, and traces without becoming execution truth.
Persistent orchestration
Use the scheduler for persistent roots, child agents, waiting, wakeups, steering, and controlled cancellation.
Traceable execution
Persist runs and steps, query traces, and inspect execution after the fact instead of losing the runtime story in logs.
Controlled tool surface
Combine builtin tools, custom BaseTool implementations, skills, and agent-as-tool composition behind explicit boundaries.
Operator path included
Run the SDK directly or add the self-hosted Console for sessions, scheduler state, traces, and Docker deployment.
Comparison
Evaluate Agiwo against graph-first, provider-first, and chat-first stacks.
The comparison guide focuses on runtime ownership, orchestration semantics, observability, and how much control you keep as systems become persistent, multi-agent, and operator-facing.
Read the comparisonFAQ
Common questions from first-time evaluators.
What does runtime harness mean in Agiwo?
It means Agiwo treats execution control, orchestration, observability, persistence, and operator visibility as first-class runtime concerns instead of implementation details hidden behind prompts.
When should I choose Agiwo over graph-first or provider-first frameworks?
Choose Agiwo when you want explicit runtime boundaries, persistent orchestration, tool contracts, and traceable execution rather than a graph DSL or a provider-specific orchestration story.
Does Agiwo include a control plane?
Yes. The self-hosted Console provides an operator-facing control plane for sessions, scheduler state, traces, agent configs, and Docker-managed deployment, while the SDK remains usable on its own.
How does Agiwo support self-improving agents?
Agiwo already provides the runtime pieces that make improvement loops practical: traces, persistent state, skills, memory retrieval, context rollback, and tool-result retrospect. Teams can layer evaluation and refinement policies on top of those runtime facts.
Can I start simple and add orchestration later?
Yes. You can start with a single Agent and the same model/tool APIs later extend into scheduler-managed roots, child agents, and Console-backed operations without switching frameworks.
Start building
Explore the harness, compare the tradeoffs, and run Agiwo yourself.
Begin with installation and the first agent flow, then go deeper into orchestration, runtime boundaries, Console operations, and comparison guides.