One direction.Every agent.Every step.

A reasonable decision. Yesterday's goal.

Suppose your sales agent is optimizing for new revenue. You change the priority to retaining existing customers, but its running workflow still carries the old instructions. The agent can execute its task correctly while working toward yesterday's goal.

A goal tells an agent what to optimize. Principles help it judge how: protect long-term trust over short-term metrics, for example. We want agent systems to optimize locally without losing coherence globally.

Kyno gives mission and principles one authoritative source. Adapters refresh the agent's context from it, whether direction changes or stays the same. The model still has to interpret that direction and make a sound decision.

Direction as a runtime primitive

A task says what to do next. A policy defines what is allowed. Direction supplies the mission and principles used to judge tradeoffs. It has its own identity, version history, and read interface, so an organization can update it while task instructions stay the same.

For example, an agent can keep the task “draft a reply to this cancellation request” while the mission changes from increasing renewals to making cancellation straightforward. The next successful pull supplies the revised mission and principles. See the runnable example.

Agentic self-governance

Your framework schedules tasks and runs agents. Permissions and security controls restrict the available actions. Humans define mission and principles; agents decide how to apply them within those boundaries. This is bottom-up agency. Kyno supplies versioned direction before a step, not a prescribed decision. An optional verifier evaluates the result.

In the animation, the workflow continues after an operator publishes a new version. Each successful pull supplies it at that agent's next step. The final state shows delivery, not proof that the agents followed it.

Questions before you integrate

How does direction relate to a system prompt?

A system prompt can carry direction alongside instructions for a model call. Kyno manages the direction's identity, current version, and history independently. An adapter retrieves a version and supplies it in the model context; the prompt carries that copy. A fixed prompt may be sufficient for a short workflow with unchanging direction.

Can I keep my constitution in Git?

Yes. Git provides authoring, review, and file history. Kyno provides the runtime read interface and versioned direction that integrations consume. Review a constitution in Git, then apply the approved file:

kyno apply constitution.yaml --note "Reviewed support priorities"

Run this command in the Kyno workspace, or with a configured remote profile. Automatic Git synchronization is deferred.

Is Kyno an orchestrator?

Your framework continues scheduling tasks, invoking tools, and running agents. Kyno stores and delivers direction through MCP. Its adapters connect that direction to the workflow you already have; updates do not rewrite tasks or replan the workflow.

Is Kyno an AI governance system?

Kyno supplies runtime organizational direction: your current mission and principles. Principles can describe how to judge tradeoffs; tradeoffs are not a separate field in Kyno. Permissions, approval processes, and enforcement belong to the surrounding system. Model training and alignment remain separate too; even a well-trained model needs your organization's current direction.

Does Kyno prevent drift or guarantee alignment?

No. Kyno stores versioned direction and its adapters pull it before work proceeds. Pulls can fail, and an agent can receive the right principles and still misinterpret them or make a bad decision. Claims about improved behavior require evidence from the actual integration and task.

What happens if a pull fails?

By default, the binder logs the failure and uses cached direction. If it has never fetched direction, it supplies empty version 0. Configure PullPolicy(fail_closed=True) to raise an error instead. Current direction depends on a successful pull; an update committed after that read becomes available on a later pull.

Do I need a verifier?

Verification is optional, but recommended. Your application can check outputs against their supplied direction using its own checks or an independent verifier. Those assessments can feed back into the running workflow, giving your application a chance to correct course and improve outcomes before the run ends. Your application chooses whether to continue, retry, or ask a person to review the result. Kyno supplies direction; it does not run verification or decide what happens next.

When is Kyno useful?

When several agents need shared direction, when priorities change during a run, or when your integration needs to record which direction a step received. For a short workflow whose direction is fixed, an existing prompt or file may meet your needs.