Vigile
SearchContents

Product

The vision

Vigile is a planning and coordination layer for people and agents who work together. Each part of that is marked here as usable today, or as a direction that is not built.

The idea

People and agents increasingly work together. A longer list does not coordinate them; one observable plan can, when everyone shares its rules.

Vigile holds outcomes, containment, dependencies, responsibility, state and history in one graph. People, agents and programs use the same checked operations. It is not only an issue tracker or an agent screen, but the control plane of coordinated work.

Who it is for

  • Today A lead or an engineer who coordinates several agents and a few people

    One service on one machine, or on a network they trust: everything this site documents.

  • Mixed A product or engineering team with parallel work and dependencies

    Today, one plan where whoever is let in may change all of it. Access by team is a direction.

  • Direction A platform team that governs many agents

    Today each agent can have a user and a key of its own. Rules that a platform sets for its agents are not built.

  • Direction An organisation that needs one plan across teams and tools

    Not built. An instance is one plan in one place, with no link to other tools.

It guides, and does not only store

A plan that agents work from has to lead them to plan well and keep moving, by what it teaches and by how its tools behave.

  • Today Guidance

    One loop, taught by what an agent is told on connecting, the guide and each tool's description: read the plan from the top, ask what is next, read the task and its version, start only when the work starts, keep statuses and structure true, finish when the work is shown to work.

  • Today How the tools behave

    A stale or unsafe move is hard to make. Changing a task names the version the change was based on, a task cannot start before what it depends on, and list_next_tasks answers from each task's priority, its dependencies and who has it. A refusal names its rule and actions that lead out.

  • Today Area priority directs next work

    list_next_tasks compares priority from the outermost group to the task and returns that path.

  • Direction An observer of plan health that nudges

    Not built. Today the shape of the plan is there for whoever looks.

  • Direction Guidance fitted to an agent's role and state, measured by evaluations of agents

    Not built. Today the guide is the same text for every caller.

What it changes

  • Mixed A dependency between two teams is visible

    Today a task can wait for a task, or a whole project, elsewhere in the same plan, and the graph draws the arrow. Across plans that are kept apart, it is a direction.

  • Mixed A stale claim is noticed

    Today list_stale_tasks finds assigned work quiet for 24 hours, on demand. A proactive observer is direction; neither releases or reassigns it.

  • Mixed A policy refuses a move that conflicts

    Today the built-in rules do, and of two agents that take one task one is refused. Rules that a team sets for itself are a direction.

  • Today Decisions and history survive a handoff

    The description, the reason, each status and who changed what stay with the task. The next agent or person reads them with get.

Why the ceiling is higher than the product

Each direction rests on a choice that is real and can be checked.

  • Today One definition of an operation makes its MCP tool, its HTTP endpoint, its command and its page here: one contract.

    Direction An integration, or one more interface, written once against the same rules.

  • Today The plan is a graph of items and typed links; next, waiting and progress are worked out from it.

    Direction Views across many projects and teams, and an observer that reads the same graph.

  • Today Every change is checked in one place and refused with its rule.

    Direction Rules that a team sets, and automation that may do only what they allow.

  • Today Versions and history: who did what, on which version, is kept.

    Direction Many actors on one plan, and the evidence an observer goes by.

  • Today The engine reaches its data through a contract that a second store already meets.

    Direction A store for a hosted service.

  • Today A line in the log for each change, and a stream that says when the plan has changed.

    Direction Watching a plan from outside, without asking the agents.

  • Today Users of three types, each under a key of its own.

    Direction Access by team.

The directions

What it is today