Put it in your product.
Let your application use the know-how that already helps your agent.
You’ve found a useful Skill. Now use it in your app.
The Skills you install already help your agent do useful work.
With FLOW, that know-how can power your applications, too.
From useful Skill to useful software
That useful Skill?
That useful Skill?
Make it a feature.
The Skill you trust can become a method your app calls. Give it data. Get a result your software can use.
A spreadsheet Skill can become the intelligence behind your import button.
Explore another use case
Your contact importer
contacts.csv3 rows · ready to preview
Map contact fields
Your preview is ready.2 ready · 1 email to check
Know-how, inside your feature.
From a useful method to a repeatable step
Put the know-how
Put the know-how
in your workflow.
Call a method when a file arrives. Pass its result to checks, review, or the next task.
The same contact mapper can power a step in a larger process.
Build with small methods
Your import workflow
A spreadsheet arrivesStart with the source file
Map contact fieldsCall your reusable method
FLOW
Prepare the reviewCheck the rows and pass the result on
One clear job. A useful next step.
From instructions to a capability it can call
Give your agent
Give your agent
a specialist to call.
Let an agent call a method and work with its result. Keep the procedure in one place, ready for the next request.
Your app, workflow, and agent can build on the same useful method.
Find a host or add support
Your agent
Map contact fieldsCalling a specialist method
Through a host with FLOW support.
Start further along.
Reuse a useful method across projects, then improve it as you learn.
Pass the method on.
Give another builder a method they can apply, evaluate, and build on.
Why propose a successor?
Keep what made Skills useful.
Keep what made Skills useful.
Make the whole method callable.
SKILL.md made agent know-how easy to package and share.
FLOW proposes the next step: a common way for software to invoke, check, and combine that
work.
| Built into the standard | SKILL.md |
FLOWThe successor proposal
|
|---|---|---|
| Readable instructions | Included in the standard | Included in the standard |
| Bundled resources & code | Included in the standard | Included in the standard |
| Shared invocation interface | Left to integrations | Included in the standard |
| Defined inputs & results | Left to integrations | Included in the standard |
| Code, agents, prompts — one interface | Left to integrations | Included in the standard |
| Declared method calls | Left to integrations | Included in the standard |
| Live message channels | Left to integrations | Included in the standard |
| Optional schema contracts | Left to integrations | Included in the standard |
Existing Skills may need adaptation. FLOW requires a compatible host. Check compatibility
What makes this possible
One shared boundary.
One shared boundary.
More ways to build on your work.
Once a method has a common calling interface, you can choose how it works, combine it with specialists, and evolve it while keeping the calling model consistent.
Readable by design
Start with a file.
Start with a file.
Grow it when you need to.
Keep instructions in a readable FLOW.md. Add resources or optional
contracts as the method grows.
Code, agents, prompts
Choose how.
Choose how.
Keep the same call.
Use code, prompt instructions, or agents. Your application calls each through the same interface.
Explore the common interface
Built to compose
Small pieces.
Small pieces.
Bigger possibilities.
Give each method one clear job. Combine specialists into a capability you can understand and improve.
See how capability compounds
Connected as it runs
A result at the end.
A result at the end.
A conversation along the way.
Return an outcome and output. Exchange live messages while the work runs, through explicit channels.
Explore channels
Runtime agnostic by design
Your method.
Your method.
Your runtime.
Every FLOW.<ext> meets the same interface. Bring the language or runtime
your method needs.
The extension is open. FLOW treats them equally.
Each host chooses what it can run.
FLOW.md
FLOW.py
FLOW.ts…FLOW.<ext>
One shared FLOW interface
Equal at the boundary.
Free to work differently inside.
One interface, different implementations
A customer request in.
A customer request in.
A checked decision out.
A FLOW can run code, agent instructions, or both.
Here, an agent interprets the request and code checks the records and credit policy.
The customer’s request
“I was charged twice.
Please credit the second payment.”
Two payments · same invoice
ch-101SettledUSD 24.00
ch-102SettledUSD 24.00
Interpret the request.Check the records.Code · Instructions · Both
One interface for your app.
The result your app can useCredit eligibleUSD 24.00
✓ Duplicate payment verified✓ Within the credit policy
A decision, ready for your application.
No credit has been issued.
Your next step
Start with a Skill
Start with a Skill
you already find useful.
Choose a method whose value you understand.
Give it a clear input and result, then put it to work in a compatible host.
Bring the know-how.
Review what your Skill needs. Adapt it into a FLOW.md, or choose code when
the procedure calls for it.
Put it to work.
Use a compatible host. It supplies the execution, tools, providers, and policy your method needs.
Explore Jig, the first FLOW hostBuild on it.
Call other methods. Add optional contracts when collaborators need exact inputs, results, or channels.
Build a host or integration
Where FLOW runs
Try FLOW today.
Try FLOW today.
On a host that supports it.
Jig is the first host to implement FLOW.
Run your methods there, or help bring FLOW to the tools you use.
Help grow the ecosystem
Bring FLOW to your coding agent.
Add support with a pull request to one of these projects.
Build an integration with the host guide
A few useful details
Small standard. Fair questions.
Can I bring an existing SKILL.md?
Simple instruction-based Skills can become Markdown Flows when their package and requirements fit the runtime. Scripts, tools, resources, and session assumptions may need adaptation. Read the compatibility guide ↗
Does FLOW choose my framework or model?
Your method owns its procedure and internal orchestration. A compatible host supplies runtime support, providers, credentials, powers, and policy. FLOW defines the shared package and invocation boundary. Explore the concepts ↗
Do I need a formal contract for every method?
No. Start with the ordinary input/result boundary. Add an optional
FLOW.contract.json for validation, outcomes, or channel ports. Named
contracts earn their place when independently maintained collaborators need an exact
interface. Read about contracts ↗
Can I use FLOW today?
FLOW is in public alpha. Specifications and SDKs may evolve. Jig is the first supporting host. FLOW is runtime agnostic; each host determines which implementations it can execute. Check runtime support ↗
Your next project
can start ahead.
Build on a method you already use.
Give the next builder something to build on.