Protocol concept / reference runtime in progress
One work object across humans, agents, and systems
Agintent is a protocol concept for turning scattered requests, agent runs, approvals, artifacts, and memory into one continuous execution chain.
The orchestrator is the first reference runtime. It exists to make the model concrete against real execution constraints, not to pretend the full ecosystem is already here.
Core idea
One durable work object should survive planning, routing, execution, human review, and final outputs.
Current shape
The first runtime is being used to shape the protocol against real execution, review, and artifact flows.
Problem / Why This Needs To Exist
Current agent work breaks at the handoffs
The issue is not that models cannot generate. The issue is that real work moves across planning, execution, approvals, files, and memory without one durable object holding the chain together.
Break 1
A business request starts in one place and gets rebuilt again in every next tool.
Break 2
Agents can plan, but execution, approval, and finalization still happen in disconnected systems.
Break 3
Artifacts, logs, and memory drift away from the original request, so continuity becomes manual work.
Manifesto note
This is not a finished platform claim.
It is a claim about how mixed human and agent work should be structured. The protocol comes first. The first app exists to test the model against reality instead of leaving it as pure theory.
That is why Agintent is being presented as a concept, a vocabulary, and a reference runtime direction at the same time.
Protocol / What Agintent Defines
Agintent turns a request into a durable execution object
The goal is not another chat shell. The goal is one shared object that can be emitted, routed, executed, reviewed, and extended over time without losing continuity at every tool boundary.
Request Envelope
Protocol term: Envelope. The durable object that keeps identity, source, routing hints, lifecycle, artifacts, and memory references together.
Requested Outcome
Protocol term: Intent Object. The work being asked for, for whom, with what constraints, and with what expected result.
Execution State
Protocol term: Run Contract. The execution layer for accepted work: capability selection, state transitions, logs, waiting states, completion, and failure.
Outputs And Memory
Protocol term: Artifact Contract. Outputs that remain attached to the original work instead of disappearing into separate apps, folders, and chat threads.
Envelope v0.1
The first vocabulary is already taking shape.
Agintent is still early, but the model is already being made concrete. The envelope, intent object, run contract, capability vocabulary, and lifecycle states are being shaped through a real reference runtime.
{
"protocol": "agintent.envelope",
"version": "0.1",
"source": { "actorType": "human" },
"intent": {
"object": "intent",
"status": "queued"
},
"run": {
"executorCapability": "browser_automation"
},
"artifacts": [],
"memoryRefs": []
}Pilot Flow / One Concrete Scenario
What this looks like in real work
The point is not abstract protocol purity. The point is that one business request can move through agents, automation, review, and final outputs without being rebuilt from scratch at every handoff.
01 / Intent
An operator asks for a launch
A human starts with a messy business request, not a perfect payload.
02 / Agent Work
An agent turns it into executable work
The request gets normalized, planned, and routed without losing the original context.
03 / Human Review
Approval becomes a native state
The run can stop for review, expose the right artifact, and continue intentionally.
04 / Continuity
Outputs stay on the same chain
Artifacts, decisions, logs, and memory remain attached to one work object over time.
Example work object
A launch request stays intact while the system works around it.
Original request
Launch a new domain, prepare the landing page, route the build, and bring back artifacts for approval.
Work object timeline
One request, one chain, one context
What happens
A human sees why the run paused and gets the right artifact for a decision.
Attached artifact
Preview + decision note
Reference App / First Working Surface
The first reference application is an orchestrator
Agintent is not only an app idea. It is a protocol idea. The orchestrator is the first surface being used to prove how raw intent can become envelopes, routes, runs, artifacts, memory, and human review.
What it is
The first reference application is an orchestrator. It accepts raw intent, normalizes it into envelopes, routes work by capability, tracks runs, and preserves outputs for review.
What it is not
It is not the final boundary of the project and not a claim that the full protocol ecosystem already exists. It is the first working surface used to prove the model.
Reference runtime
Intake
Raw operator intent enters the system before being normalized into a protocol shape.
Routing
Work routes by executor capability so acceptance stays explicit.
Run state
Execution becomes inspectable through queued, running, waiting, completed, failed, and cancelled states.
Outputs
Artifacts and memory stay attached to work instead of dissolving into disconnected backends.
Flow / How Work Now Moves
Emit. Normalize. Route. Run. Attach. Review.
This is the model Agintent is trying to lock: one request moves through the system without changing identity every time it crosses a tool boundary.
Human remains first-class
Manual review is a native state, not an afterthought.
A run can pause, explain why it is waiting, expose relevant artifacts, and then resume or finalize intentionally. That is what makes mixed execution between humans, agents, and workflows practical.
01 / Emit intent
A human, agent, workflow, or system emits raw work into a shared protocol surface.
02 / Normalize
The request becomes a versioned envelope with an explicit intent object.
03 / Route capability
The system selects a capability, not just a named worker, so acceptance and rejection stay clear.
04 / Run
Execution happens through a run contract with visible state instead of hidden glue logic.
05 / Attach outputs
Artifacts and memory references accumulate on the same work object over time.
06 / Review and finalize
A human can inspect, pause, resume, approve, reject, or finalize without losing context.
Status / What Exists And What Is Next
Agintent is in protocol-definition and reference-runtime stage
This matters because the project should feel ambitious without pretending to be further along than it is. The protocol is being shaped against real runtime constraints while the first implementation keeps the idea grounded.
What exists now
Protocol vocabulary
Envelope v0.1
Protocol-native routes
Reference orchestrator runtime
Capability-first routing foundation
What is still being built
Stronger run contract
Better human-in-the-loop supervision
Artifact and memory semantics
External emit and consume flows
Production hardening
Current commercial posture
Early design partners, pilot conversations, and protocol followers make sense now. Public self-serve onboarding does not.
Closing thesis
If the model holds, Agintent becomes the shared coordination layer for human-to-agent and agent-to-agent work.
Right now it is a protocol being shaped in public through a first reference runtime. That is exactly the right stage to define the language, the object model, and the execution shape before the ecosystem hardens around worse defaults.