See the work take shape
The Project Agent works on the same canvas you do. Sketches, typed blocks, connections, and revisions remain visible while a fuzzy request becomes an executable process.
Automation for knowledge work
Turn fuzzy recurring work into a process you can see become reliable.
Describe the outcome inside a project. The Project Agent sketches the work on a visible canvas, runs it safely in Test, and records what happened. Keep the discretionary parts that help; replace the repeated, reliable parts with typed blocks, policies, and deliberate human review.
I know what a useful result looks like, but not every step. Start with the outcome, watch a Test run, then formalize what repeats.
Test first. Approve one exact snapshot for Production.
A desktop canvas — best explored on a big screen.
Start with the work as it is
Freestyle is the on-ramp, not the destination.
Most useful processes do not arrive fully specified. You know the shape of the result before you know every step. A Sketch gives the agent room to produce that first result while Functionary captures the prompt, tools, inputs, outputs, and decisions that made it possible.
Those captured runs are evidence. Watch what repeats, add the constraints the agent needed, and graduate stable work into blocks with declared inputs, outputs, effects, and discretion. Trust grows by removing dependence on in-the-moment choices where the evidence says you can.
Visible · Bounded · Auditable
Built around what automation gets dangerously wrong, quietly.
Put discretion in its place
A Sketch may begin with open-ended agent work. Tool ceilings, declared effects, human pauses, and Test mode make that discretion visible and constrain what it can change.
Turn runs into evidence
Captured runs record inputs, outputs, configuration, model activity, and execution lineage. Extraction blocks can also attach the passages behind structured findings.
Sketch · Test · Graduate
The agent works in the process, and helps make the process better.
The Project Agent can create canvas state, connect blocks, use project knowledge, and Test the result while you watch. Where the process is still unclear, an executable Sketch can do the work with declared instructions and tool ceilings. Where the process is understood, use narrower typed blocks.
You rarely know the exact process up front, but you know useful work when you see it. The canvas makes that reactive loop durable: ask, watch, correct, and keep the result as project state rather than a private prompt habit. Runs and transcripts remain available as evidence for the next refinement.
Test mode lets you exercise representative inputs without committing external writes. Review each step according to its declared determinism and discretion. When the evidence supports it, narrow the Sketch, add a validator, insert a human pause, or replace agent work with a deterministic implementation.
Humans are first-class participants, not edge cases. Approval, manual input, inspection, and review stay explicit wherever accountability cannot be delegated.
Agent Sketch Test Runs Typed Flow
What's different
Plenty of tools draw the pipeline. Functionary shows the judgment inside it.
A visual canvas is table stakes — every automation tool has one, and they all show you the same thing: the plumbing, what connects to what. What they leave as a black box is the step where an agent made a call. Functionary gives discretion a visible place and captures what the run consumed, produced, and invoked. Extraction blocks can attach supporting passages to structured findings; every successful block records its execution lineage. The canvas becomes a place to improve the work, not only a wiring diagram.
Who it's for
Start with recurring work whose shape is clearer than its implementation.
Functionary is for knowledge workers who can describe a useful outcome but should not need to specify a complete program before they begin. Start with an agent-backed sketch, learn from real Test runs, and invest in formalization only where the work repeats and the evidence warrants it.
- Research and analysis
- Monitor sources, extract findings, compare evidence, draft recurring briefs.
- Customer operations
- Reconcile feedback, classify intake, route exceptions, prepare responses.
- Internal operations
- Triage files, assemble reports, coordinate reviews, publish artifacts.
- Project teams
- Turn a shared body of knowledge into repeatable, observable work.
- Process owners
- Start from the desired outcome and formalize the reliable parts as they emerge.
- Technical operations
- Combine typed blocks, reusable modules, connectors, and explicit human pauses.
What it is not
It earns trust by refusing scope.
- Not an invisible general-purpose agent. Discretion has a visible place in the flow, explicit instructions, and a path toward tighter constraints.
- Not one-click certainty. A useful first run is the beginning. Reliability comes from testing, observing, and formalizing what works.
- Not a low-code app builder. Functionary builds automation flows, not user-facing applications.
- Not your external system of record. It still persists flows, run state, artifacts, and project knowledge needed to do the work.
- Not a replacement for judgment. It routes judgment to the right person at the right time.
Your process should outlive the prompt that started it.
Flows are readable JSON. Project state and execution history live under an operator-selected data root. Model providers and connectors are explicit choices, so you can decide where information is allowed to go.