Share your best AI workflow. We could show it to 2M+ people.

Turn a collection of documents, reports, spreadsheets, and notes into an evidence-backed decision brief with ChatGPT. Instead of asking AI to simply summarize the information, this workflow makes it identify what matters, connect the evidence, compare it with historical context, explore scenarios, and highlight what should be considered before making a decision. Step-by-step: 1. I gather the information relevant to one decision, including reports, PDFs, spreadsheets, research, historical data, meeting notes, and existing analysis. I upload everything into ChatGPT. 2. I ask ChatGPT to understand the situation using this prompt: > “Analyze the information I provided and build a structured understanding of the situation. Identify the key entities, important facts, relationships, metrics, trends, assumptions, and constraints. Do not make recommendations yet.” This creates the context before jumping to conclusions. 3. I build an evidence brief by asking: > “Create an evidence brief. Separate verified facts, derived insights, assumptions, conflicting information, and missing information. For every important conclusion, identify the supporting source or evidence.” This gives me a clearer picture of what is known versus what is inferred. 4. I add historical context when it is available by asking: > “Compare the current situation with the historical information provided. Identify meaningful patterns, similarities, differences, and changes. Highlight which historical observations could be relevant to the current decision.” This turns historical data into context rather than simply another report. 5. I explore three scenarios by asking ChatGPT: > “Based on the evidence and historical context, evaluate three scenarios: upside, base case, and downside. For each scenario, identify the assumptions, key drivers, risks, likely impact, and evidence supporting the assessment.” The objective isn't to pretend the future can be predicted perfectly. It is to understand how the decision changes when assumptions change. 6. I generate the decision brief by asking: > “Create a concise decision brief containing: > > 1. Current situation > 2. Most important evidence > 3. Key insights > 4. Historical context > 5. Critical assumptions > 6. Key risks > 7. Scenario analysis > 8. Evidence gaps and uncertainties > 9. Questions that should be investigated > 10. Possible actions and their implications. > Do not make the final decision on my behalf.” This produces a structured decision brief instead of another AI-generated summary. 7. I review the brief and challenge its conclusions before making the decision. I ask follow-up questions such as: > “Which assumption has the greatest impact on this decision?” > “Show me the strongest evidence against the current conclusion.” > “What information would most likely change the recommendation?” The AI helps structure the decision, but I make the decision. The important shift is: Summarize the information → Understand the situation → Establish the evidence → Add historical context → Explore scenarios → Evaluate the decision This approach can be applied to almost any domain where decisions depend on complex and interconnected information. A property investment is one example. A business strategy, product decision, operational problem, financial analysis, research question, or engineering decision can follow the same pattern.

Most AI agents are effectively static. You write their instructions, use them repeatedly, notice where they struggle, and manually tweak the prompt when something goes wrong. Valuable feedback from real work is often lost, so the same mistakes can keep happening. I created a self-improvement flywheel that uses actual agent performance data to improve agents over time. The system collects two kinds of evidence: - Task scores showing how well each agent performs across different quality dimensions - Run telemetry and review outcomes revealing recurring failures, coordination problems, and cases where actual behavior differs from expectations A scheduled weekly cycle analyzes that evidence, identifies patterns, creates improvement proposals, evaluates whether those proposals are safe and broadly applicable, updates agent instructions when appropriate, and measures whether those changes actually improve performance. The goal is not to let agents rewrite themselves freely. It is to create a controlled learning loop. Step-by-step: 1. Collect performance data while agents work. Score important outputs across consistent quality dimensions, and record useful execution telemetry such as failures, decisions, reviewer outcomes, and unexpected behavior. 2. Analyze performance trends on a recurring schedule. Calculate per-agent averages, identify weak dimensions, compare agents, and look for improvement or decline over time. 3. Mine run history for recurring patterns across multiple sessions, including agents that repeatedly struggle, low-quality runs, and cases where expected behavior differs from what actually happened. 4. Turn repeated problems into improvement proposals. Before proposing a change, inspect the agent’s current instructions so you do not add a rule that already exists. 5. Evaluate each proposal before applying it. Check whether the lesson is broadly useful, redundant with existing instructions, or in conflict with established behavior. 6. Separate low-risk and high-risk changes. Automatically apply additive or clarifying improvements. Escalate conflicting changes for human review instead of allowing the system to fundamentally change an agent’s behavior on its own. 7. Look for system-level problems. Analyze patterns across agents to identify quality gaps, missing capabilities, or coordination failures that cannot be fixed by changing one agent alone. 8. Apply approved improvements and preserve the history. Update the relevant agent instructions, archive the processed proposals, and version the changes so they remain inspectable and reversible. 9. Measure whether each change actually helped by comparing agent performance before and after the refinement. If quality does not improve, do not automatically assume the change was useful. 10. Repeat the cycle. As agents complete more real work, the system gathers more evidence and gets another opportunity to improve. Instead of treating agent instructions as static prompts, I turned them into a continuously improving system: Work → Evaluate → Find Patterns → Propose Changes → Refine → Measure → Repeat The important part is that the loop is evidence-driven and controlled. Agents improve from real usage, but low-confidence or behavior-changing updates still require judgment rather than being applied automatically.

Most AI agents start with someone writing a prompt from scratch. I wanted a better way. So I built an Agent Creator. I describe the kind of agent I need, and it determines whether I actually need a new one, figures out how that agent should work, creates it, and adds it to the rest of my agent team. Step-by-step: 1. I describe what I need by telling the Agent Creator what I want the new agent to do. 2. It checks what already exists by reviewing my existing agents and skills. If something already does most of the job, it recommends improving or reusing that instead of creating another overlapping agent. 3. If a new skill is needed, it researches the role, including current best practices, common mistakes, useful tools, and what good work looks like in that area. 4. It creates the agent by defining its job, required information, outputs, available tools, and the steps it should follow. 5. It gives the agent the right skills by creating or reusing supporting skills, including examples, reference material, and checks that help it work consistently. 6. It sets clear boundaries so the agent knows what it should handle, what it should not handle, and when another agent should take over. 7. If the new agent belongs in an existing workflow, it adds the agent to the team by updating the handoffs so the other agents know when to use it. 8. Before finishing, it checks the agent’s work by running validation checks to confirm that the new agent follows the standards I’ve set for the whole team. The result is that I don’t have to manually design every new agent from scratch. I can describe the kind of help I need, and one agent can research the role, create the new specialist, connect it to the rest of the system, and make sure it’s ready to use. In other words, I built an AI agent that can help grow its own team.

We built an evidence-driven Agentic AI workflow for extracting trustworthy investment intelligence from messy real-estate documents. The problem wasn't simply getting an LLM to read PDFs. Real-estate investment information can be distributed across reports, underwriting documents, valuation materials, rent schedules, spreadsheets, tables, and multiple versions of the same information. A metric such as IRR can also appear several times with different scenarios, dates, classifications, or meanings. Instead of building another "chat with your documents" agent, we designed a controlled agentic workflow around one principle: Don't make the agent smarter. Make the workflow harder to fool. Step-by-step: 1. I start with the business question. The agent receives a request for a specific investment metric for an asset and determines the business context instead of immediately searching for matching words. 2. I resolve the entity by normalizing the asset or entity using aliases, identifiers, relationships, and hierarchy information. This prevents ambiguous names from sending retrieval in the wrong direction. 3. I build a metric-specific plan using governed definitions for important metrics. A definition can include the metric's business meaning, terminology, preferred sources, classifier information, negative cues, and extraction rules. The agent starts with a contextualized retrieval and extraction plan rather than a vague instruction such as "find IRR." 4. I discover the right documents by narrowing candidate source documents with metadata and path-level information before searching the entire corpus semantically. The goal is: Find the right document before finding the right chunk. 5. I retrieve evidence within the selected documents. Only when scoped retrieval is insufficient does the workflow fall back to broader semantic retrieval, keeping the agent's search controlled and auditable. 6. I inspect structured information when necessary. Important investment information frequently lives in tables rather than paragraphs, so the workflow escalates to table-aware processing to inspect rows, columns, schedules, and structured financial evidence. 7. I extract a structured result instead of a long free-form answer. The result preserves the metric, value, unit or context, source document, page or location, and citation information. 8. I validate the evidence by checking the extracted value against the metric definition and relevant validation rules. Depending on the metric, these checks can include unit, scenario, chronology, plausibility, and table-to-text consistency. 9. I resolve conflicts explicitly. If multiple plausible values are found, the agent does not simply select the first result. The workflow applies rules for source precedence, chronology, scenario classification, and evidence strength. If a conflict cannot be safely resolved, the ambiguity is preserved rather than hidden. 10. I produce an evidence-backed result containing the selected metric, supporting evidence, context, and lineage. The result can then become a structured business artifact for downstream analytics, reporting, or decision-support workflows. This is not simply Question → RAG → Answer. The workflow is Question → Understand → Ground → Plan → Retrieve → Inspect → Extract → Validate → Resolve → Evidence-backed output. Retrieval is one capability inside the workflow. The agent coordinates the process, chooses the appropriate tools, follows the retrieval policy, handles structured evidence, and moves the result through validation and resolution. The biggest improvement did not come from giving the model more freedom. It came from giving the model better boundaries, better domain knowledge, better tools, and explicit decision rules. This pattern can be applied beyond real estate to financial research, insurance, compliance, legal documents, due diligence, and other enterprise workflows where an answer needs to be not only useful, but defensible and traceable.

Having a team of specialized AI agents creates a new problem: someone still needs to decide which agents should work on a project, what order they should work in, what each one needs from the others, and whether the project is actually finished. Without coordination, the human becomes the project manager, manually moving context and outputs between agents. I created a project-manager agent that acts as the orchestrator for my AI team. I give it an objective, and it determines what work needs to happen, selects the appropriate specialist agents, sequences their work based on dependencies, and presents the execution plan to me before anything starts. Once I approve the plan, it coordinates the agents, manages their handoffs, tracks project state, and maintains enough persistent context for the work to continue across sessions. Step-by-step: 1. I create several specialized agents with clearly defined responsibilities, capabilities, and expected outputs. 2. I create a project-manager agent that knows what each specialist does and is instructed to orchestrate the work rather than perform specialist work itself. 3. I give the project manager a high-level objective. It analyzes the goal, inspects the project context, identifies the required work, and selects the appropriate agents. 4. I have it create an execution plan showing which agents will be used, what each one will do, their dependencies, and the order of execution. 5. I require human approval before execution begins. I can approve the plan, narrow the scope, change the sequence, or redirect the project as needed. 6. Once the plan is approved, I let the project manager delegate each task to the appropriate specialist and pass relevant context and prior outputs between agents through structured handoffs. 7. I track progress and project state as the agents complete their assignments. If an agent uncovers new work, fails review, or changes the project assumptions, the project manager updates the plan and routes the next work accordingly. 8. At the end of the session, I save the current state, completed work, important decisions, and next actions so another session can continue without reconstructing the project from scratch. Instead of personally coordinating every AI agent, I manage the project at a higher level: I define the objective, approve the plan, review important decisions, and evaluate the result. The AI project manager handles the coordination layer, turning a collection of specialized agents into a team that can execute complex, multistep projects coherently.

This Codex-driven workflow takes a software request from problem understanding through implementation, validation, review, and delivery evidence. Instead of asking an AI coding agent to simply “build the feature,” it gives the agent an explicit development lifecycle with defined responsibilities, deterministic validation gates, repair loops, and human checkpoints. The goal is to make AI-assisted development more structured, observable, and recoverable. It can be used for new feature implementation, bug fixing, refactoring, test creation and improvement, code quality and security hardening, and documentation and automation changes. The core principle is simple: Don't give the AI only a coding task. Give it an engineering lifecycle to work on. Step-by-step: 1. Understand the problem. Clarify the request, identify the desired outcome, define the scope, and surface ambiguity before implementation begins. The output is problem understanding and scope. 2. Define constraints. Identify technical, functional, non-functional, compatibility, and out-of-scope constraints. The output is a constraint set. 3. Plan. Analyze implementation options, select an appropriate approach, break the work into tasks, and define acceptance criteria. The output is an implementation plan. 4. Inspect the existing system. Review the relevant codebase, dependencies, current behavior, and affected components before making changes. The output is system context. 5. Implement. Make the smallest appropriate code changes while following the existing project’s conventions and the approved plan. The output is code changes. 6. Run deterministic validation. Run tools that can objectively validate the implementation, including formatting, linting, type checks, builds, unit tests, and other available automated checks. The output is validation results. 7. Review. Evaluate the implementation against the original requirement, the plan, code quality expectations, security considerations, and potential regressions. The output is review findings. 8. Repair and iterate. If validation or review identifies problems, diagnose the issue, make the required correction, and repeat validation. The output is a corrected implementation. 9. Verify. Confirm that the acceptance criteria are satisfied and that the relevant tests and checks provide sufficient evidence for completion. The output is a verification result. 10. Produce delivery evidence and handoff. Summarize what changed, what was tested, what passed, known limitations, and any remaining decisions requiring human attention. The output is delivery evidence and a human handoff. The core loop is: Implement → Validate → Review → Repair → Validate → Verify. Testing and review are treated as part of development rather than activities performed only after coding is “finished.” AI coding agents are increasingly capable of inspecting repositories, writing code, running commands, and responding to failures. The problem is that capability alone does not provide an engineering process. This workflow separates the responsibilities an AI coding agent performs into explicit stages. It applies several principles: - Problem before implementation: Understand what needs to change before writing code. - WHY before HOW: Establish the intent and constraints before choosing an implementation. - Single responsibility per stage: Give each stage a defined purpose and output. - Deterministic validation first: Use tests, linters, type checkers, builds, and other deterministic tools wherever they can establish correctness. - Failure localization: When something fails, identify which stage or assumption needs correction. - Evidence-based completion: Support completion with validation and review evidence rather than an AI declaration that the task is finished. - Human checkpoints: Use automation to accelerate execution without removing human judgment from important decisions. The broader idea is: The AI should participate in the engineering system, not become the engineering system.

AI agents can generate impressive work quickly, but the agent that created something is not necessarily the best judge of whether it is correct, complete, secure, or ready to move forward. Without an independent review step, mistakes can compound as later stages build on work that was never properly validated. I created a system of specialized AI review agents that act as quality gates between stages of work. Instead of letting the agent that performed the work decide whether it is finished, a separate reviewer evaluates the output against explicit criteria and makes a gate decision: PASS or NEEDS REVISION. Different reviewers focus on different dimensions. In my software development workflow, I use reviewers for implementation fidelity, code quality, security, performance, and specification compliance. A feature does not advance until the required reviewers have passed it. Step-by-step: 1. Define what “good” means before the work starts. Give reviewers an explicit source of truth, such as a specification, plan, acceptance criteria, coding standards, security rules, or quality rubric. 2. Separate execution from evaluation. The agent that performs the work should not be the only agent deciding whether that work is acceptable. 3. Create specialized reviewers for important quality dimensions. For software, this might include implementation, code quality, security, performance, and specification reviewers. The same pattern can be used for research, writing, factuality, compliance, financial analysis, or brand review. 4. Run the appropriate reviewers when a stage is complete. Each reviewer independently inspects the work from its assigned perspective and actively looks for reasons it should not advance. 5. Require an explicit gate decision. A reviewer must return either PASS or NEEDS REVISION, along with concrete findings and recommended fixes. In my workflow, reviewers can block progression for issues such as missing tests, even when the underlying implementation appears correct. 6. Route failed work back to the appropriate agent. The worker fixes the identified problems and submits the work for review again. 7. Advance only after the required gates pass. Later stages should not build on work that still has unresolved review findings. 8. Keep humans at consequential decision points. AI reviewers can determine whether work satisfies their assigned criteria, but important actions such as merging, deploying, publishing, or otherwise committing the result can remain human decisions. Instead of treating AI-generated work as complete simply because an agent produced it, I create a controlled loop: Build → Review → Fix → Re-review → Pass → Advance The result is a more reliable workflow where specialized agents perform the work, independent agents challenge it, and errors are caught before they propagate into later stages.