Core Runtime
Minimal kernel, stable by design
AI Agent Runtime
The execution base for the new agent paradigm.
Guga organizes models, tools, permissions, and context into a recoverable, auditable, embeddable runtime so agents can move from conversation into real products.
- Small core
- Plugin-first
- Event ledger
- Runtime permissions
Event Stream LIVE
- user.message Find the Q3 growth bottleneck
- model.plan Plan a 3-step analysis
- tool.exec run_sql(query)
- tool.result rows: 1,024
- permission.check fs.write allowed
- artifact.create report-q3.md
- assistant.message Report generated
Core architecture
One core, endless plugin ecosystems.
Guga Agent starts from a minimal kernel. Every capability plugs in, so you can compose, replace, and extend the runtime that fits your product.
Official plugins
Common capability domains covered
Ecosystem
Community and custom plugins can grow freely
Plugin marketplace and protocol extensions
Unified integration standards with hot swapping, version compatibility, and rollback.
AI SDK Provider
Multi-model access, streaming, function calling, retry policy
Filesystem / Shell
Safe execution, sandboxing, audit quotas, command allowlists
Skills (MCP)
Skill wiring, protocol adapters, capability expansion, orchestration
Session Store (JSONL)
Persistent sessions, resume points, portability, auditability
Context Policy
Context trimming, compression, priority rules, budget control
Core Runtime
Core Runtime
Lifecycle | State machine | Events | Hooks
Permissions | Context | Storage | Audit
Git / Code Tools
Repository actions, commit audit, PR analysis, diff editing
Files and Artifacts
Structured artifact storage, indexing, references, lifecycle
Replay and Audit
Event replay, audit trails, visualization, report export
CLI Workbench
Debugging, running, observing, TUI / interactive shell
Agent Profiles
Roles, permissions, toolsets as reusable templates
Event Stream
ToolCallread_file
ToolResultread_file
ModelCallgpt-4o
Permissionapprove
Plugin Marketplace
Discoverable, installable, and version-managed
Designed for reliability
Build agents around a runtime boundary
Clear boundaries make agents recoverable, auditable, and safe enough to embed in real products.
Small core, broad edge
The core owns lifecycle, state, events, hooks, and permissions.
Plugins are first-class
Providers, tools, skills, MCP, memory, and UI all plug in.
Events are the source of truth
Replay, audit, evaluation, and UI derive from persisted events.
Runtime enforces permissions
The model proposes intent; the runtime decides what executes.
Context is a projection
Runtime assembles, budgets, compresses, and reinjects context.
Core Runtime
Lifecycle, state machine, events, hooks, permissions
AI SDK Provider Bridge
Multi-model access, streaming, function calling, tools
Filesystem / Shell / Git Tools
Safe execution, sandboxing, auditing, quotas
JSONL Session Store
Persistent sessions, resume, portability
Artifact Store
Structured artifact storage, indexing, references
Replay Audit
Event replay, traceability, visualization
Default Context Policy
Context trimming, compression, priority policy
Skills & MCP
Skill library, MCP protocol, capability expansion
CLI Workbench
Debug, run, observe, share
Code Agent Profile
Task orchestration, change integration, test runs
Deep Research Profile
Evidence organization, source attribution, deep research
Review / Eval Profile
Review flows, scoring, feedback loops
Roadmap
What is built, and where it goes next.
Guga keeps the runtime small and clear, then expands product capabilities through auditable plugins.
View docs ->NOW
Ready- runtime contracts
- plugin host
- permission pipeline
- event ledger
- JSONL sessions
- replay audit
- CLI workbench
LABS
In progress- autonomous coding task loop
- deep research evidence ledger
- review / eval profile
- memory governance
- web search
COMING
Planned- desktop workbench
- web event viewer
- browser / computer-use tools
- plugin marketplace
- remote sandbox
- semantic session search
- remote sync
- enterprise policy console
- HTTP / OAuth MCP
- IDE adapters