How we make our company programmable with Offloop TaskFlow

Software has spent seventy years making more of the world programmable. Machines came first, then information, data, transactions, and now language and reasoning. Each transition expanded what software could represent, control, and compose.

The modern company is a product of that history. Customers live in a CRM, money moves through an ERP, projects become cards, and decisions become documents. Almost every object inside a company now has a digital representation.

While building Offloop, we kept running into the same contradiction. The objects were digital; the operating logic between them still lived in our heads.

We still had to notice an investor email, research the sender, decide how to respond, carry context into the next conversation, and remember when a human decision was needed. Marketing had the same problem across research, outreach, negotiation, and approval.

We had programmed nearly everything inside our company. We were still running the company itself by hand. TaskFlow is our attempt to change that.

We have all the tools, but we still run the company manually

Take our fundraising inbox. Gmail stores the message, our CRM stores the investor, Drive stores the deck, and Calendar stores the meeting. Every object already exists in software.

The operating loop still requires a person. Someone has to notice the email, decide whether it is a real investor signal, research the fund, choose how much to disclose, draft a response, ask for approval, update the pipeline, and remember the next follow-up.

Our marketing work has the same shape. The creator list lives in a spreadsheet, contact history lives in the CRM, and contracts live in Drive. A person still carries each creator through research, qualification, outreach, negotiation, approval, and booking.

Digitization records the objects. Programmability executes the transitions between them. It means an investor email can activate the right research, route into the right response path, pause at the right authority boundary, and resume from the same state after a decision.

Traditional automation can execute stable rules. Our fundraising and marketing paths change with the evidence, so they also require interpretation. Agents give us that adaptive execution capability.

Models can work, but they lack coordination and context

We already use models to research an investor, summarize an email thread, draft a response, analyze a creator’s content, find contact details, and prepare a counteroffer. These are meaningful pieces of work, and the models perform many of them well.

The company still advances through our attention. One of us chooses the next prompt, moves the result into another tool, explains the context again, checks whether the work is usable, calls the next Agent, and decides when the company can act.

For fundraising, a research Agent may produce an excellent investor profile. Someone still has to connect it to the current email, decide the response strategy, preserve sensitive boundaries, and bring the final draft to the right person.

For marketing, a research Agent may use last quarter’s positioning while a deal Agent uses this quarter’s budget. A writing Agent can combine both into a polished proposal built from incompatible context.

Model capability gives us productive workers. Organization supplies shared context, responsibility, interfaces, memory, and decision rights. People currently repair those structures by hand every time the work moves.

This is where the word “harness” becomes useful. A harness restrains and guides power while connecting it to a working system. At the company level, TaskFlow is our most important Agent harness. It gives each Agent bounded work, the required context, an output contract, permitted tools, a budget, a route for the result, and a clear authority boundary.

We started by programming our own operating loops

We began with work we already do. These operating loops repeat often enough to encode and change often enough to require Agents.

Fundraising is one example. An email to fundraising@offloop.org triggers a TaskFlow that first separates real investor interest from noise. For a qualified message, an Agent inspects the thread, researches the sender and fund, and determines what the investor is asking for.

The path changes with the evidence. A vague introduction may receive a polite, high-level response. A known investor with a concrete ask can move into scheduling or a more specific reply. Sensitive details stay out of the draft, and nothing consequential is sent until the right person approves it.

This encodes how we fundraise: what deserves attention, which context matters, where an Agent can act, and where our judgment must enter.

We use the same pattern in marketing. For an influencer campaign, TaskFlow can fan out across a creator list. Agents search for direct and manager contacts, analyze content, score audience fit, check brand safety, and estimate a rate band in parallel.

Each creator runs as an independent branch under the same campaign policy. A low fit score closes the branch. A reply activates negotiation. A proposed offer reaches us for approval before TaskFlow sends an agreement or books the creator.

Fundraising and marketing use the same four primitives. Nodes assign bounded work to people or Agents. Edges define sequence, parallel work, conditions, and revisions. The runtime preserves live state across replies, retries, and long waits. Human gates reserve consequential decisions for us.

Together, these primitives turn our operating knowledge into an executable harness with ownership, context, review, budgets, and decision rights.

Autonomy needs a control plane

As we started using Agents for real operating work, we learned to measure autonomy by useful progress inside explicit boundaries. An eight-hour Agent run can compound the same error for eight hours.

What we need is a closed loop: define the outcome, observe the result, compare the two, then advance, revise, retry, stop, or escalate.

Human gates mark boundaries of authority. Publishing a company position, spending significant money, changing production, or making a legal commitment belongs to an accountable person, even when an Agent can propose the action.

Without those controls, a research Agent may follow an interesting tangent for hours and spend ten times the expected budget. Other failures are equally familiar:

• An engineering Agent notices adjacent technical debt and rewrites code outside the requested service.
• A growth Agent finds a contact list and starts sending messages before anyone approves the claims.
• A review Agent repeatedly says “make it better,” creating an endless revision loop.
• A recovery Agent mistakes a timeout for failure and repeats an external action that already succeeded.

The common cause is missing operating controls: budgets, tool boundaries, acceptance contracts, retry policies, idempotency rules, and gates before irreversible actions.

The run pauses with the evidence, risks, alternatives, and unresolved questions already assembled. A person decides, and execution resumes from the same frontier.

Budgets, permissions, retry policies, and loop limits encode the same principle. Agents receive freedom inside explicit boundaries; the company retains control over when responsibility changes hands.

In TaskFlow, research stops at its budget. Engineering is limited to authorized repositories. Review can loop twice before escalation. Fundraising replies and creator offers stop at human gates.

The control plane governs how far the work may go. People retain authority, and Agents execute within the approved bounds.

A run should survive the session

Our operations last longer than model sessions. They wait for replies, external systems, and decisions in another timezone. If state lives inside one conversation, every interruption turns one of us into the recovery mechanism.

TaskFlow separates the durable run from temporary workers. The plan revision, node state, outputs, events, and current frontier persist independently of any individual session.

If a worker stops, another continues from confirmed state with the completed work and context intact.

For example, our fundraising Agent can research an investor at midnight, then wait for a reply or an approval the next morning. Our marketing flow can pause for days while a creator considers an offer.

None of those pauses should erase completed research or restart the conversation. The run simply waits at its recorded frontier.

Each run points to an immutable plan revision, so an outcome can be traced to the exact operating model that produced it. Runtime state records the attempts, owners, outputs, and decisions made under that revision.

This creates an operational ledger. It shows what activated, what evidence returned, which review rejected it, who resolved a gate, and why the frontier advanced.

The execution graph is the company’s missing map

Our org chart maps authority: who owns a function and who may make a decision. The operating path from an investor email to a meeting, or from creator research to a signed agreement, remains invisible.

TaskFlow gives us a second map organized around an outcome. It shows active branches, dependencies, owners, usable results, reviews, and the decision that can move work forward.

The two maps meet at gates. The org structure determines who may decide; the execution graph determines when the decision is needed and which evidence reaches it.

Agents take bounded responsibility inside a run, constrained by a contract, tools, downstream dependencies, and decision rights.

People decide. Agents execute. TaskFlow coordinates

For us, a programmable company has explicit coordination between people and Agents.

People remain responsible for direction, taste, risk, exceptions, and commitments. Agents do the bounded work: researching, reasoning, creating, operating tools, and adapting to evidence. TaskFlow connects the two by carrying context, activating work, enforcing interfaces, preserving state, and routing decisions.

Adding Agents without this layer creates more coordination work. One of us becomes the router for a virtual team: forwarding the investor email, pasting research into a reply, moving creator data between tools, and checking whether someone approved the terms.

The person ends up manually operating an Agent swarm.

In a programmable loop, Agents provide the labor and TaskFlow carries the operating mechanics. We enter for judgment, risk acceptance, and company commitments. TaskFlow handles the routine handoffs.

Ronald Coase explained firms through coordination costs: search, negotiation, contracting, inspection, and dispute resolution shape how work is organized. Internal coordination carries the same tax.

TaskFlow targets that layer. For us, productivity means completing an accountable outcome with less human coordination.

The company is the next abstraction

We expect the programmable company to emerge one operating loop at a time: fundraising inbound, creator outreach, a customer escalation, a product launch.

Each loop turns implicit operating logic into explicit responsibility, interfaces, dependencies, feedback, governance, and memory. Over time, the operating model becomes versioned, observed, executed, and improved.

We are building Offloop as composable organizational capabilities: bounded units with clear inputs, outputs, decision rights, and operating history.

TaskFlow is our first concrete step. It gives our team and our Agents a durable execution model in which ambiguous work stays adaptive while we retain control over how results become decisions.

Software made machines, information, transactions, and communication programmable. AI makes ambiguous knowledge work executable. With TaskFlow, we are starting to make our company programmable too.