What DaemonCore is
A software platform for teams building AI agents that take action.
DaemonCore gives agents defined responsibilities, checks proposed actions against permissions and policy, and records decisions and outcomes along configured execution paths. Teams can inspect who requested an action, under whose authority, and what happened next.
It is for developers building agent workflows and platform teams responsible for their permissions and audit trail. A useful starting point is a workflow where an agent should be free to investigate and recommend, while changes to the world require explicit authority.
Illustrative example · not a runtime recording
A code review, from request to record.
Follow one task from request to decision. The agent chooses how to work; the configured governance boundary determines which actions may proceed.
-
A team requests a code review
Review a proposed change and report your findings. The reviewer can read this project, but cannot change files or deploy it.
-
The agent proposes an action
The reviewer asks to read a project file. Its request carries the task, its identity and the proposed action.
-
DaemonCore checks the permission
On the configured execution path, the request is checked against the reviewer’s role, project scope and policy before it proceeds.
-
The boundary changes what happens
Reading the permitted file is allowed. A proposed deployment is rejected because it exceeds this reviewer’s authority. This example assumes enforcing mode and tools connected to that boundary.
-
The team can inspect the record
The record connects each request to its actor and decision. Execution results are separate: allowing a read does not, by itself, prove the review finished.
Step 1 of 5: A team requests a code review
Want the recorded evidence? Inspect RUN-001’s admission trace. That capture ran in advisory mode, with no model execution or blocked action.
What it provides
Authority
Agents do not grant themselves authority. Identity and permissions are established externally — verified, not self-asserted.
Boundaries
Permissions and execution constraints are external to model intent. The deployment must connect those constraints to its execution paths.
Governed communication
Agent-to-agent work moves through defined messaging roles and schema. Messages that fail validation do not route.
Execution decisions
Proposed work reaches an explicit admission point. The governance gate decides before the action proceeds — admit or reject.
Evidence
Captured runtime events provide an inspectable record: what was requested, by whom, what was decided, and why. Traceable to context and authority.
Where it sits
Your models generate proposals and your orchestration coordinates the work. DaemonCore supplies the agent’s operating definition, routes governed requests through runtime services, and checks admission along the configured paths to tools and actions.
The runtime contains services, a CLI and compiled operating definitions. Integrating a workflow means defining roles and project scope, connecting its execution paths to governance checks, and capturing the results. The tools, credentials and host permissions must support those boundaries.
DaemonCore is under active development. The public site provides documentation and a partial recording. Access to the runtime and an integration discussion start with a conversation with the team.
What this enables
- Control permitted actions — connect policy checks to the tools that act
- Multi-agent governance — multiple agents, governed roles, controlled paths, single boundary
- Vendor independence — different AI providers under unified governance with separate runtime attribution
- Auditable operations — inspect captured requests, decisions and execution results against their recorded authority
- Evaluate multi-agent risk — inspect each actor, assignment and tool boundary as the system grows